So if you want to use Unreal, consider just learning C++ as you go. That's my only point.
233 karma · joined February 19, 2020
So if you want to use Unreal, consider just learning C++ as you go. That's my only point.
Guess what--It's hard to get a good job with a criminal record, and it's easy to have a criminal record when you are black/brown.
So you take a bad job. And with that job, you remain so poor that you cannot handle the slightest emergency. A huge bill or disaster in your life (medical; car; legal) can pretty much end you. If you don't have a strong network to support you, you become homeless.
How do you reconcile the fact that most homeless people have some sort of family structure that is not homeless? I've never seen any evidence that homelessness is an inherited condition.
You blame both will power and genetics. Why are you so anxious to believe that society has no role in creating or solving this problem? If you make access to education equitable; if you don't ruin people's ability to engage with the economy with drug offenses that statistically appear quite racist in their skew; if you treat mental problems with medical assistance rather than criminal justice systems; if you regulate housing markets to prioritize making housing affordable rather than prioritize generating passive income for upper classes-- you can have a meaningful reduction of homelessness.
I'd much rather write C# than C++, but I'm a big believer in just adopting whatever is standard practice for the space your in. It's a great opportunity to learn the language, and you'll benefit more from a community's collective wisdom.
Edit: But this is still really cool and potentially useful.
No one can explain why the icons, fonts, and toolbars from 3 years ago aren't good enough anymore. No one can explain why we need constant "refreshers".
Let's say you have a new microwave. Every microwave's controls are a little different, but you know generally the conventions of their limited interfaces. There are presets; separate non-microwave functions like timers; maybe a light and a fan control.
The first few times you use it, it's a little weird. But you use the same one for like 5-10 years at a time. It becomes effortless, second nature. Food in, door shoot, beep-boop-beep by muscle-memory. Your food is ready.
Imagine someone snuck into your home and rearranged the buttons, and changed some underlying functions. Now, when the timer is done, you don't hit the timer button to clear the display--you hold the cancel/stop button that also turns off the microwave. They think it's more logical that way.
It doesn't matter, but it's frustrating. "Why was that necessary?", you might ask yourself. Neither way is fundamentally more or less logical. It's just different.
It's not that changes are bad, but semi-annual changes for utilitarian things seem excessive. You accept a certain amount of change when you replace your microwave, or your car, or your computer. But not when you take your car to be tuned up. They don't replace the break pads, and then change the location of the stereo's volume knob.
I think he philosophy of heavy handed redesign was useful in bringing computer interfaces to up to new hardware specs early on in tech, but we're reaching a point where they should be slowed down in favor of utility. The claim that it is design in the name of usability is no longer true. Call it what it is. It is merely seasonal fashion and nothing more. Some fashions are timeless. We should find them and stick with them as defaults that we are very hesitant to change.
Consistency can facilitate clean design, allowing you to conceal and expose complexity by strongly established conventions, helping to achieve balance on the beauty-utility continuum.
The production is there. The money is there. If we simply won't do this, we aren't worth preserving as a society.
You can have 10. You can have... 10!
Enjoy your chrome book while mountain biking! Don't feel like carrying it back down the mountain? Drop it off a cliff, pull #2 out of your bag
Enjoy your chrome book while water skiing! It's not water proof, but who gives a shit?! Throw that baby in the lake.
I love my iphone 7 and my macbook air from 2013--no doubt, they are very good. But I could throw my windows pc in the garbage and rebuy it a couple of times over for the cost of comparable hardware from apple, and I'm just not having the problems you are describing. This is like 6 year old computer that was about $1,300 in parts. It's like, just some asus motherboard with mismatched ram and a video card.... and it works fine. My mom has a 10 year old windows computer that just keeps on spreadsheeting and e-mailing for her... just fine. I just don't understand.
I've also had apple hardware that has issues. The notion that it is issue free is just not true.
A compile time error is a caught error. A run time error may be, or perhaps not.
A statically typed language with compile-time type checking would flag that immediately, and chances are your IDE will show the error before it even gets to that point.
Type hints are a thing, but then you are already moving in that direction while remaining in python.
But if you really care about security, and if you are managing a linux OS where you have a lot of deep access to the system, I think saying "I have better things to do with my time than understand the system I'm managing; that's what vendors are for" is a lazy perspective.
Consider this: https://github.com/systemd/systemd/issues/6237
Order of events here: - RedHat creates systemd to handle init and daemons--something that used to be handled mostly by shell scripting and much simpler tools.
- Debian and RHEL based systems adopt systemd. That's most Linux systems.
- About 6-7 years later, an issue is noticed and reported by a user. If a user creates a service to be run under a username beginning with a number, which some distros (not RHEL or Debian though), systemd validates the name (why?) by matching it against a regex.
-If validation on any field fails, they categorically ignore that field and run the service.
-In this case, because it is the user name, it runs the service as root instead of the user name.
-Their response? "This is how the system handles all fields. We do it for consistency and compatibility. Closed."
-That was 3 years ago. This was never fixed. "It's not a bug! Just don't give systemd a potentially valid user name that looks like that!"
So using the daemon system promoted by RedHat (who we trust!) has created a situation where a process--possibly a server or something public facing--could be run as root without you immediately realizing it. You don't care to understand your system, but you do have to operate it. RedHat won't do that part for you. So, you could create these conditions unknowingly.
It wasn't malicious, but what's important is that it isn't necessary.
Look at what kinds of questions did the RedHat maintainers ask?
"I wonder what tool allowed you to generate this file?" A totally useless question, given these files are frequently generated manually. "It's the tools fault! Whatever it is. Even though it might be a valid username on your system."
A better question might be "Why do we have to validate/parse the username field at all?" After all, parsing bugs are well-known for creating security vulnerabilities, and if the name is invalid, then there will be no user, and the service will fail in the same way it does when the username string is syntactically valid but there is simply no user. In short, they have a product that "helps you manage your OS; and from RedHat (who we trust!)", yet we find that it increases complexity; does unnecessary work; and results in a bug that could allow a process to run root when it should not.
This scenario is so similar to the flatpak sandbox issue. "It's not a bug. It's just that most people are misconfiguring it." Fine! But you chose to embrace the added complexity of a system (flatpak) that you just don't actually need. It has pros and cons. It's not a matter of trusting RedHat not to be malicious--it's trusting them to make that judgement for you. Their judgement is not perfect.
There is a medium that exists between "audit every line of source in the system yourself" and "trust implicitly everything a vendor says and does". I think that RedHat is reputable and trustworthy, and they are trying to push Linux forward, but they are simultaneously reinforcing their position as industry experts through creating software that "eats linux". It's not malicious, it's just the nature of their existence. Your interests and their interests are not the same, so it makes sense to consider things for yourself.
Maybe the patch fixes a vulnerability, maybe it creates one. Maybe the company pushing security is really pushing mindshares of ecosystems for subscription revenue and industry influence.
Build from source; keep your packages as minimal as possible; keep your permissions as granular and restricted as you can manage; and pray to your gods of choice.
I can't understand why people are so anxious to embrace so much unneeded complexity. Things that "just work" always just work until they just don't.
If you are overweight, any weight loss may be good. If you aren't really overweight, eating healthy regularly timed meals and working out are probably a better bet for maintaining your physique.
In practice, I think I would prefer the latter, even if it is less clear and purely logical. I mean, the US is railing against inquiries over war crimes this week. Though that particular action is entirely irrational, it seems unlikely that the USA would enforce GDPR on the behalf of the EU short of a very large company violating it flagrantly. If I run a local nonprofit in the US that serves the elderly of my community, and the EU-resident child of one of my clients donates to my organization, by which I wind up collecting their information--repercussions seem frankly very unlikely. Firstly, I doubt my non-profit would be pursued for such a violation by the offended nation, as they do have optics to maintain. Secondly, I have no physical presence in their jurisdiction against which to enforce the regulation, so my own government would have to enforce it on their behalf, which currently seems unlikely to me (though I'm not an expert on such things by any means).
Depending on their specific activities (information collection, in the case of GDPR); whether or not they are physically present in the jurisdiction of whatever regulation; and their home country's foreign relations with the foreign government who originated the internet law, a company can choose to comply with foreign internet law--or not--at varying degrees of risk. As messy as it is, this seems better than firewalls to me.
Perhaps explicit agreements with foreign governments are needed in this area. That seems preferable to firewalls, arbitrary risk-taking, or mindless compliance with a foreign law.
Granted, if significant revenue is generated they'll have to exist officially in one place or another in order to report the income, but not all such sites would need to generate such income, and could forgo it specifically for the purpose of violating local regulations in some cases.
But that's the main content, and about 5% of the comments.
From the article:
"This pattern is consuming — instead of creating. Consuming — without questioning. Consuming and hiding behind an authority.
I saw developers taking other people's solutions for granted. Not thinking twice about the approach, not bothering about analyzing it."
It's normal and within acceptable limits, but if you want to find a circle jerk devoid of critical reasoning--a celebration of consumption over creation--it is very much alive here.
And that's fine, really, so long as we never stop being aware of it.
You can write a compiler for python in python--but it still needs the original cpython (or jython, or ironpython, or pypy, etc.) to run, because there is no compiled binary produced by your python code.
You can write a compiler for any language using python, but you need one of the interpreters you mentioned, and you can't throw it away unless it produces a binary. Maybe Cython can do this. But if it needs an interpreter to run, you'll have to keep the interpreter around as a non-python dependency.
But who cares? Unless you rewrite a Pygame from scratch, or replace it with another graphics library, in which case you need to rewrite snakeware from scratch, none of this is relevant here.
It's just insane. You are proposing rewriting entire language runtimes and/or graphics engines to preserve 1400 lines of python code (mostly a menu, a calculator, and a game of snake), with the supposed goal of creating an all python user space, and dismissing it as "Who says you can't do it?". I'm not saying it's impossible, but it makes no sense. You'd be better off starting over and taking this on with a different strategy. If your end goal is an all Python user space linux distro that actually works like linux, this project is a non-starter without being totally reimagined with virtually 0 reuse of the code that's there even at a conceptual level. You wanna rewrite pygame or python's compiler? Be my guest! It has nothing to do with your supposed objective though.
At the very least, you would need to get out of the pygame window simulation, start using a standard graphics compositor, and replacing existing utilities with python alternatives to make this work. But again, even CPython, Jython, PyPy, etc. will need to remain. Maybe Pygame can be made to work with PyPy, in which case you get close to what you want--but it's still a C extension, not python. And that's your graphics renderer. So why not just use Wayland or something then?
I think the quest for language purity at the OS level is a fun dream to pursue, but you need to decide where to cut it off in terms of scope and how to implement the scope you choose.
Should I assume they are looking at scratching every single line of code they've written for this and restarted? Why would I make that assumption?
I don't want to quibble with you. My only point here is that an all-python user space is a significant undertaking if you are willing to acknowledge the scope of what the user space actually entails. It's totally doable, but this project isn't even a step in the direction of solving those problems. It's a totally different thing.
Depending on the objective in a "python only" operating system, I may be inclined to strongly advise not trying to reimplement everything in python. The nature of C is such that you can write a C compiler in C, compile it, throw away the source code, and use the compiled binary for the new compiler to start developing a new compiler for C. But you can't like, make a python interpreter for python, in python, delete CPython, and then use the python version. It is dependent on CPython. And so, to build it, it's dependent on GCC, make, a shell, etc.
These are great tools. I think you should keep them, and define a specific surface area that python interfaces with. That's all I'm sayin'.
It's all part of the user space. You can hide it within the snakeware application (why?), but don't deny it exists in the Linux user space. And C Python needs C extensions (pygame, for example), so GCC is at the very least a very-very-nice-to-have, is it not?
What is the goal here? You want to run Python without a shell? A huge number of python scripts depend on the shell. You are increasing barriers to using Python to code interesting apps in this system. Should the shell be implemented in Python, too? It could be, but why? Why not just integrate a standard shell, and present some nice-ish way of interfacing with it via Python?
I don't think that this application itself can even work in such an environment (no shell, no init system, etc). Currently this project is depending on a shell provided by Busybox. It uses these underlying tools to initialize and configure the operating system. It's all there in the user space, just hidden beneath this application.
Look, there are no laws about this sort of thing. You can do what you want and call it what you will, and I'm not some tech lingo fascist trying to impose my idea of "user space" on anyone (even though it's really a term with a specific meaning of 'anything outside of the kernel', for which making an all-python version sounds highly difficult). I'm merely pointing out that a great deal of this user space is actually already non-python, and user space carries with it a lot of linux's essential functionality, largely via the GNU core utils and other common utilities which are written in a wide variety of languages. You can choose to hide all of that functionality to make a python-only sandbox... but.... then...
...Couldn't I just use pygame to make standard applications that run on all distros outside of this isolated "window manager" program? All this achieves right now is isolating your apps in this kind of simulated window environment, and preventing the user from ever doing anything meaningful unless they have a specially coded snakeware(tm) python app. It can never run a standard installation of something like Firefox; utilize any standard Linux CLI software; utilize an existing package management system or the packages from it; etc. because it has no shell, and doesn't make use of the standard Linux graphics compositors (X11/Wayland).
So having said all of that, my goal isn't to tear down the project, but to ask the hard question for the benefit of this project: What is the goal? What I see here is mainly a simulated window manager written in pygame which can only ever run specially-created GUI apps, which is booted into directly. This design can never become a viable distro as it stands.
This is a cool project. A fun project. But first and foremost, this is about 1400 lines total of Python and shell script. It's not really all that much yet, and it's not going to get there by pretending this design is sustainable to become some robust user environment where everything is Python. Sometimes, complying with standards and specifications are what make a thing the thing it is. And this is not a Python-only user space Linux distro. It is a simulated window manager written in Python that runs on a Linux kernel in a standard shell using a compact subset of standard tools written in other languages, and conceals the rest of user space on which it itself depends.
But maybe it's just easier to pretend the whole thing isn't a single process running on a single core, non-Posix compliant, incapable of running standard Linux GUI or CLI apps; and that all of that sacrifice in functionality hasn't been specifically engineered to cater to some misguided aesthetic notion that this all makes the system more hackable because it is a written in Python. Maybe it's easier to simply pretend that you can't build a python window manager that works with native linux graphics compositing systems, and that the whole design would be better off targeting certain configuration processes using Python.
What you have here is basically a very simple pygame template with an embedded application build tool chain. Which is totally cool, and potentially fun and productive. But it isn't replacing the GNU/Linux user space, which is C heavy, but very language diverse.
I would focus not on replacing the user space, but interfacing with it where reasonable. To that end, you may even want to consider shedding pygame and interfacing with X11/wayland. Identify the surfaces you want to control with python and implement that. It will perform better, and be more true to what makes Linux "Linux".
It requires uncommon persistence, and a love (if not an aptitude) of abstract reasoning in pure form.
I think the thought process goes like this: "What's he doing?" "He's doing THAT!?" "Why?!" "I don't understand why." "This software is garbage."
Some people claim to be able to glance at code and know what it's doing quickly, but it's just not possible to ingest a few thousand lines of self-referencing logic and understand it quickly if it is doing much more than shuttling data between a database and some kind of display rendering.
If you've learned to program, you must have learned patience for yourself. You have to show that same patience to the authors of other programs if you want to understand their work. There are many thoughts embedded in their code. It is deeply complex as the person who wrote it.
Even if the entire application is stored locally, the goal is frequently on code reuse with systems like React, so it is still baked into the design.
We talk about function keys being missed--but the fact is, one of the main issues is that your web browser already makes use of many of these keys. This is not a problem with the web app you are using, but with the fact that you are using a web app, which is a client running within your browser, itself a native client.
Simply returning to native desktop clients for productivity software would be a huge step in the right direction. There are economic incentives not to accommodate this user need, however. Developers need to offer cloud-based, app-based access to their services in order to remain competitive. For many companies, it is built into their SaaS business model! If you develop a productivity application professionally, you would need to believe that the existence of the native client (and all of the resources and man hours it consumes) will give you a meaningful competitive edge. The benefits to users are obvious to developers who have time to reflect on it, and to the users running a POS system, but not to the people several levels above the POS operator who are making decisions. For them, a cloud system that centralizes access, control, and supervision works better for them.
I had a job recently where I had to do data entry for a lot of invoices into a intranet cloud system. The system was slow; fields had bugs that literally caused the text to be entered backwards for some reason (seriously)... and it sucked for me. But for our business partner who was a majority owner of our main asset, it affords them control, centralization, and remote administration.
I actually agree with the OP aesthetically, but it dwells on the POS operator and forgets the hidden user-- POS operator's managers and business ownership.
I will also say that to those of you who feel anti-javascript--an SPA is much better at managing stateful applications than dynamically pages generated by the server, and I'd much prefer to minimize chat between client and server where possible, which SPA frameworks do afford.
I think the whole thing could be improved by better support for native-style applications in the browser, possibly running in some "native mode".
The last thing all say is that windows are nice for multitasking, but they do represent a significant cognitive load to manage, and you can't usually do it from muscle memory. I remember teaching my grandparents to use AOL in around ~2000, and I literally had to make exercises for them to try to establish "object permanence" with windows that were hidden. The interface appeared flat to them, and they didn't intuitively grasp that another window jutting out behind another was a part of a separate interface altogether. They got it eventually, but it is the type of thing that is easy to forget when we live our lives enmeshed in window based operating systems. But look at phones--they don't have window-like functionality even after all this time, with bigger and better screens, multi-core processors, etc. Why? Because we still consider a phone to be a "device". It's capable of multitasking, but we subdue that aspect of the interface in favor of focus and usability. Terminal applications are similar in that respect, and I think that's why people find them attractive in some contexts.
To anyone who feels strongly about this, I'd say: Develop a beautiful productivity app for native desktop usage. Market it. Make people fall in love with it. A deluge of such apps may promote a reversal of this trend.