I don't have much experience with them but I think VxWorks and QNX are good examples of simpler OSs. I do have some experience with Minix3 and it is certainly one. I guess the BSDs stand somewhere in the middle.
1,287 karma · joined March 5, 2011
https://catwell.info
I don't have much experience with them but I think VxWorks and QNX are good examples of simpler OSs. I do have some experience with Minix3 and it is certainly one. I guess the BSDs stand somewhere in the middle.
https://bugs.eclipse.org/bugs/show_bug.cgi?id=509072
I learned about this when I added cloning the Linux kernel repository to an integration test suite for a cross-platform filesystem. I had to use another project because of that file :)
I do prefer what Sublime Text is doing here though. Kudos to them, it's a lot of work.
A lot of people have had that idea over the years (remember John Gage's "the network is the computer"?) You could even argue The Shockwave Rider, a 1975 Science Fiction novel, described it pretty well.
I don't know about the Steve Jobs quote though, do you have a link?
Their superior safety has been known for a long time as well, which is why all 58 French reactors active today are PWRs (and most of those in the US are as well).
That being said, it is still probably a bad idea to put a power plant in a place which is known to be exposed to tsunami...
What you need is things like [1] or maybe [2]. Lua has them because it's been the dynamic language of choice for this domain for years (with Lisps and Forths as its main competitors).
Now we see new challengers like micropython, mruby and jerryscript / iotjs, it will be interesting, but they're clearly not the mainstream choices for embedded.
Maybe it is time we stop using those titles. I personally saw that confusion cause serious issues at at least two companies.
The comparison with other filesystems does not hold since applications for other OSs have always been developed with no normalization at FS level, and hence it was done by the applications, or through the use of high-level OS APIs. Mac applications, on the other hand, expect it to be the responsibility of the filesystem. This is explained pretty clearly in the article.
On a side note, I wish Apple would have taken this opportunity to switch normalization from NFD to NFC, which basically everything else uses. The distinction causes complexity and often issues in software which share data between Apple platforms and other platforms, such as version control systems for instance.
EDIT: according to pilif's comment, they did, which is awesome!
Also, here is a paradox: take someone who has only ever seen terrible code bases and someone who has only ever seen very good code bases. How can they know? They might take a guess based on how well the software works, but that's probably not very reliable.
I think a good software engineer is someone who has seen a lot of different things, good and bad; someone who knows what design choices work and what will plunge software into the depths of Hell; probably someone who has make mistakes themselves and lived through the consequences.
But yeah, when working on such a code base, do read some code outside of it now and then, never forget there are better ways to do things. And if you are starting to feel burnt out by the quality of the code base you work on, you should probably make a change.
The views on the issue amongst the community are divided too. Personally, I have decided most of my new code won't support Lua versions older than 5.3. That means no LuaJIT. If I have to use OpenResty seriously again, I will fork and adapt it to support PUC Lua 5.3. In the meantime, I use Xavante and WSAPI for the little Web code I write in Lua.
Note that the DataGenetics article talks about 2D Voronoi cells but they (and K-Means as well) can be generalized to a space of any dimensionality.
For source code, people typically used CVS or (later) SVN. The repos were hosted by platforms like SourceForge, berliOS or Savannah, or on the projects' own servers.
Releases were tarballs hosted on servers. End users sometimes got software by downloading and compiling those, but there were already package managers and repositories. Before most people had Internet at home, at least in France, you could buy CDs with Linux packages at the press store.
Communication between developers typically happened on IRC for casual chat and through mailing lists (hosted with mailman) for serious stuff. Sometimes there were web forums to communicate with users. And conferences, of course. A lot of projects were developed by people who were physically close, for instance people who met at the same Linux Users Group.
Some projects used bugtrackers actively, some did not. It was mostly Bugzilla or Trac. That did not really change too much with GitHub.
The main difference in my mind is that forking was usually regarded as something bad. You would not fork a project and then send pull requests to fix issues.
For a simple fix, you would generate a patch and send it to the project's mailing list, where it would be discussed and eventually checked in by one of the owners. If you wanted to really engage with the project, you would become active in the community and eventually get commit rights.
I think what led to that change of model is: cheap branching in Git, GitHub as a platform with users account, and maybe Continuous Integration making it easier to validate patches.
- You must decide where you want to go next. The first thing you should think about is: three years from now, will you take the Manager path (lead a team) or the Individual Contributor path. If you choose IC, do you want to specialize, or you want to broaden your skillset and become more of a generalist? In any case, I would say work on soft skills, broaden your horizon (e.g. learn new languages, write front-end code if you do backend and vice-versa, etc) and learn one to three domains very well (look up "T-shaped", this is where you want to go). But focus on the part you will need the most for your next step.
- If you go for the generalist IC route, try to work as close to production as possible. That means: deploy your code, monitor what it does to the servers (or machines) it runs on in the wild, watch how real users use it. Also, it is time to learn how your tools (build system, programming language, OS...) work.
- If you specialize, pick something with a future, engage with the community, and if possible with Academia. Sometimes when I talk to engineers and mention I read research papers they think I'm crazy, but there is no way you'll be good at an R&D topic if all you do to keep up with research is watch videos and read popular science blog posts.
- Have fun. Don't burn yourself out working too much. Keep doing fun side projects, they teach you things you don't learn in a professional setting.
Because of that, it doesn't make sense for application developers to support the use case.
Because of that, lots of applications don't work without Google Play Services.
Because of that, few people use phones without Google Play Services.
(And then people complain about the lack of open Android alternatives, or that other OSs such as Sailfish do not take off despite doing crazy things to support Android applications.)
http://www.college-de-france.fr/site/gerard-berry/course-201...
http://www.college-de-france.fr/site/gerard-berry/course-201...
(In 2014 - 2016 he moved on to program proofs, which may also interest some of you.)
With Cloud computing, operators frequently have access to all your data. Sometimes it is part of their business model to use it (e.g. gmail). As long as you are aware of that, no problem. They typically won't use your data for things more harmful than targeted advertising (although you should check that ToS do not give them ownership of your data...), except if you're, say, a paedophile, in which case they might tell authorities (http://www.telegraph.co.uk/technology/news/11012008/Paedophi...).
In other words, your data is typically well protected as long as the cloud provider and entities which could require access to its data (e.g. law enforcement agencies from its home country or the countries where its servers are) are not part of your threat model.
I am usually for modularity, but I think this kind of security is part of the OS' job, and we have to move to security models where third-party AVs do not exist.
Of course, this is not just my opinion, see https://news.ycombinator.com/item?id=13082832 in particular.