Operating System Concepts - 2015-07-02

next day → last day (18 days later) »

6:49 PM

Hi

Greetings

Hi.

Thanks for making this chatroom

What I was talking about there was the structure of the data

Yes.

Sorry

6:50 PM

So, there are two types of Operating Systems structures.

Structure of the objects

Alright, go on

The first type is layered, what *nix uses (for the most part).

Each unit can only connect to the next unit by going through all the layers in between.

And the 2nd type?

The second style is more unit-based, which is what Windows uses.

Well

I will take the unit-style

6:52 PM

This style is easier to modify a single unit without messing around with unrelated things.

It is also supposedly easier to hack, but that depends on how well it is designed and how you handle errors and things like that.

The third style (yeah, I said there were two), is a combination of both.

Hum

I can see a mix of both working

You will also need to consider how you handle processes, which language(s) you want to use to write apps...

Javascript

Tons and tons of Javascript

How you are going to manage memory (not an issue here?), how you are going to keep the apps separate from the OS...

@IsmaelMiguel *oh the horrors!*

6:55 PM

The memory isn't an issue

What you could do is basically build a system to support Windows apps written in HTML/JS/CSS.

And the Apps will be reviewed manually

Each one will have it's own execution space

With extremely limited access

Sounds good, but it's harder than it sounds.

The only access will be to the System object

I know

And I'm ready to deal with it

OK, so how are you going to enforce this?

What happens when an app breaks out of its space?

6:57 PM

Anonymous functions in strict mode

(It's going to happen sometime if it becomes a major system.)

When the app breaks out of it's space, it will be crashed

It will be terminated

That's the idea

Terminated in a very ugly way

OK.

But show a nice error to the client and report it back to us.

(In this case, me)

Sounds good.

But, this is where you need to account for an app that somehow breaks out of its space and manages to overwrite something or something like that.

7:00 PM

Yes, I have to have a safeguard in case some smarta$$ uses the console to destroy the system

Layered systems they can only access the next layer (theoretically), until it is destroyed.

Module-based systems can access the specific module they need to split the system wide open.

The idea is to have the Layer 0.

That is where the whole system will be

The kernel.

And another layer for apps?

And each app is sandboxed?

That's the idea

But the idea is to give different access levels to different types of app

Reminds me of the Windows Universal apps.

And each app has to request the access they need.

7:02 PM

Not exactly

A widget can only read stuff, but can only write on a very particular space

Default is nothing but its source code, and you can access files/incoming internet/outgoing internet by checking boxes in the properties file.

OK.

While an App launcher can read stuff that a widget cant

And each will have different accesses to different controls

How are you going to handle managing files?

Managing files?

Yes.

If you have a file, and two threads are using it.

You will need to use a locking system.

7:04 PM

Javascript is single-threaded

OK.

What about running two apps at once?

That will be two processes sharing a single thread?

Well, each one will have a crude version of a preemptive-multitask processor

Using timeouts

Task A wants to read File B

It creates a task with 1ms of delay

Which will give time to other stuff to run

That is, in theory, it will work

Now, Task C tries to write to File B.

And Task D as well.

Task A will execute first, then Task C, then Task D

OK.

7:08 PM

Unless it is marked as locked

Then, only Task A can use it

If this was a full blown system, you would need to consider two types of locks.

A read lock, which allows multiple readers and no writers.

And a write lock, which allows one writer and no readers.

It sounds like you've got it under control, though - at least at this stage.

Well, not at 100%

There is something that is bothering me a bit

Yes?

And that is multiple logins

Well, you could start with one login per system.

7:11 PM

To make things worst: multiple logins with 2 different account types, debugging remotely another app

So one person is using two accounts?

Yup

Just treat it like two people using two accounts.

The same account, as a developer

And the same account, as a user

In Windows, you don't have one account twice, you are either in a user account or an admin account.

Either can get a developer license to test Universal apps.

7:14 PM

But I want to separate the developer tools from the regular user

And that unblocks certain features, or it appears to.

So, what I would do is have a regular user account by default.

If someone wants to develop for it (this is probably pretty far down the road, anyway), then just give them access to dev tools in the user account.

Or, if you wish, just create an app they have to use to get dev tools.

And, if you have developer privileges, you have to click in a button that loads aditional packages with the developer stuff

Kind of like installing VS, only each time you log in.

Kinda

How can I explain this better...

You are a regular user

And you have access to the developer tools

OK.

7:18 PM

Those tools are only loaded on-demand

room topic changed to Operating System Concepts: Room for discussing operating system concepts and development [os]

Sure.

The idea is to allow a console and a debugger access

And a tool to remotely access and control the other system, in a fake-vnc-like way

So, a virtual machine-type of thing?

Not exactly

Something like relaying x.org output in an SSH session using PuTTY and XMing

You see the content of the window being rendered on your side

But, in this case, the entire desktop

You execute an action and it will send a little bit of JSON

All the visible elements will be then rendered in a separated window

On your other account

I'm not sure what you mean.

7:25 PM

Imagine this:

Your cellphone has a square in the screen

Why don't you just have a dev account be a normal account with special features?

OK.

That's the idea, but those features are loaded only on-demand

Yes.

That shouldn't be hard.

It isn't

The hard part is the remote debugging

Oh.

7:28 PM

The even-harder part will be a remote canvas

To debug 2D and 3D graphics

So, what is the remote part?

Executing in the cloud and displaying on the user's system?

The remote part is you being able to control the other device/computer from somewhere else

So, why does the developer need to be able to do that?

To debug on cellphones

Oh, OK.

7:32 PM

And tablets too

Sounds like a feature that should be faced when you are actually at that point.

I know, but it is something that will escape the norm

But my issue is the distribution of the elements

Should I have it like OS.<app type>.System.<objects>?

Well, what Windows does is the phone has to be connected to the computer.

I can't debug remotelly over USB using Javascript

It had to be a low-level app

Then, the phone is literally an extension of the computer and it and the debugger can pass data back and forth.

7:37 PM

That would be a more advanced app

OK.

You could set up the cloud to send data through it.

That was the idea

Phone sends to cloud where computer gets from cloud.

It will probably take longer than USB, though.

It will for sure

The idea is to also build an entire console

So, what you should do is host the app on your server strictly separated from the rest of it.

So, an app crashing doesn't affect anything else.

7:40 PM

That's the idea

So the developer uploads it to the cloud and starts it from the phone.

Each user will have 2 areas:

The app has to log its errors, possibly with your system providing more information.

The developer then can download the log file for the app.

The error logging will be a pain

But do-able

It will.

Actually, figuring out what the error was will be a pain.

7:41 PM

And save a last-execution log

Logging it shouldn't be that big of an issue, just print a new line to a log file.

But the log file would be tremendously huge

Maybe.

Allowing only 5 logs is a better idea

Renaming files is really fast

The app will stop logging when the app crashes, and you can just save the log of one execution.

Or one log per execution, with the app name and execution start time as the log name.

7:43 PM

That would be a huge ammount of memory

Depends how much is logged.

The idea is that the debugger does the logging

On a normal-execution, no log is created

Exactly.

I was assuming the app was in dev mode the whole time.

After it is submitted, you don't need to save logs.

Unless it crashes, that is.

When it crashes, it has to write the latest error

OK, I need to go now.

If you want to discuss something else, just ping me.

7:47 PM

Alright, it was fun to chat with you

Sure, don't worry

I might return to this chat room and write something here

8:05 PM

Hullo!

Greetings

8:20 PM

Back.

Greetings dude

How goes the OSing?

I'm going to propose an OSConcepts.SE site.

That would be a good idea, but my concept wouldn't fit in there

Specific details would, though.

8:26 PM

Yes, they would

But people would spoon me to death if I ever say outloud "I'm making an OS in Javascript!!!"

9:02 PM

@IsmaelMiguel Are you going to compile the JavaScript to a machine code, or are you going to write an interpreter in another language that does compile to a machine code?

9:23 PM

I will reduce the code to a very very very very very basic subset

A very bad example of a compiled program:

'o8o!!';C=['Hello World!'];S[K[xx]](C[0]);

Or something similar

The first bytes are the header

Then a list with all the constants

Then S would point to and object to the type of program running, to have then a list of k keys.

xx would be the offset.

o8o would be based on the OS name.

!! means version 1.1

2 spaces would mean 0.0.

9:43 PM

The idea is to encode up to 95 versions in as few bytes as possible

I was thinking about defering the loading of an entire library and load only and only the essential parts

Allowing requests for specific functions

10:07 PM

in The 2nd Monitor, 5 mins ago, by Hosch250

Boo: http://area51.stackexchange.com/proposals/55360/operating-systems

10:21 PM

It's closed :/

It is :\

It wasn't very active.

At least it reached meta

There aren't many questions that can be answered

But not a lot of people have the knowledge to build an OS, and they aren't built every day, so of course it is slow.

And actually, there are tons and tons of questions that could be answered.

I could have flooded it last fall when I was taking a class on OS's.

I never had serious classes on Operating Systems

Part of my major.

I loved it, but the class was a mess.

10:24 PM

We went through the topic, but it was just scraping the surface

We had a test

There was a question that was like this:

"What is an Operating System?"

And a guy answered:

"It's divided by Linux and Office"

Not sure what that means.

It means that it is part-Linux and part-Office

Linux is an OS, and Office is not, so I'm still not getting it really.

That was the answer he gave

OK.

10:27 PM

To the question

next day → last day (18 days later) »

Transcript for

Jul '152

Operating System Concepts

Room for discussing operating system concepts and development

join this room
about this room

00:00

06:00

12:00

18:00

all times are UTC

site design / logo © 2024 Stack Exchange Inc; legal

mobile