Actually, the implementation of arenas is broken in glibc malloc() when running on multicore systems.
I have been debugging that problem for some time. The charts in the article are quite similar to the ones I got when I initially came across the problem.
Wonder how many threads does their process have? and how many cores on the machine?
There are environment variables that can adjust the behavior of malloc. They should try setting MALLOC_ARENA_MAX=4 and see if the memory usage goes down.
The core idea seems to be to map shortcuts to sequences of characters. My experiences suggest that this has promise. Using normal QWERTY, I currently type 160 wpm on average at 95%+ accuracy. I can get up to 180-190 if I risk letting typos through. I noticed that I unconsciously adopted a related idea to the one suggested here: my fingers automatically type out sequences of letters that I'm used to. For example, "-tion" is a common suffix. Instead of typing t, then, i, o, n, my fingers just bang out "tion" as one fluid motion, like a piano scale.
There's a special type of keyboard called steno that takes this further. Instead of typing out individual letters, your keyboard has about 20 keys, and you use "chords" of keys to type entire syllables at a time. Experts can reach upwards of 300 wpm. Here's a demo: https://www.youtube.com/watch?v=U7AFutd9Gos. I tried to do this but it took too much time to learn.
Like, what is wrong with my reasoning here? Meetings are maximally efficient when the exact set of people who all need to talk to each other are present, and no more. In a team of 7, only 1 or 2 other people might be affected by what I’m working on. The other people are just wasting time pretending to care about what I’m saying.
My experience working at tech companies in SF has suggested to me that most meetings, not just standups, suffer from this problem. The time cost of a meeting grows as O(N^2), and yet we routinely have all-hands, weekly syncs, etc. Yes, some level of communication is needed but when the time cost of these things is so tremendous, it seems irresponsible not to at least ask if what we’re getting out of it is worth the cost.
Meetings are apparently the one thing that no one tries to optimize, in our industry ostensibly hyperconcerned with optimizing things.
I've come to realize that stand-ups are generally useful. You're right that out of, say 15 people, only 2 care that you are struggling to import some dependency, but the rest overhear the discussion, they register some keywords and they know what you are working on. Maybe next month Joe Junior Dev goes directly to you with a question about that dependency instead of wasting half a day googling.
Then there is also the side effect of our monkey brains to give importance to people you see often. Stand-ups cultivate the feeling of "this is a team". It's important to show members what the team is.
Stand-ups however are not a requirement for a good functioning team. I'm leading a small team of senior devs and, despite my praise above, I decided against daily stand-ups. There is sufficient intelligence and communication, and just general professionalism in everyone in the team, that daily stand-ups are not worth the hassle and corporate feeling.
As a rule of thumb, if there are junior devs on the team, I would insist on having daily stand-ups on that team.
When the company I work at decided to become "agile", it all went to hell. Every "innovation" just makes it more and more miserable to work there. Standups are a real pain, and I have yet to see any value whatsoever from this daily ritual that interrupts key work time.
Because some people are luddites and cargo-culters and don't see the reasoning behind the actions
"Agile mandates post-it notes" kinda stuff
Standups could be very well replaced by a chat channel, for example. This way it's broadcast, recorded and can be a bit async as no-one needs their turn to speak
I find having context for what others are working is helpful. Not only does it mean I can help them better when necessary, I can be aware of what other people are doing in the project and head off any potential problems.
Where I work, most people in management positions work 50-60 hours a week because most of that time is spent on meetings and they have to work overtime to finish their "real" work.
I used to enjoy meetings when I first started there because it felt good to have a break from staring at a screen all day but I quickly got tired of being invited to 90 minutes long meetings on project X where my input was only needed for one point out of the 12 on the meeting agenda.
We have a weekly status meeting. Mostly it's about giving the boss an overview over workload and discuss prioritization of upcoming stuff, and that's usually the only time he'll actually manage me as such.
However it's also nice to discover if work done by other devs interact with what I might be working on. Maybe I'm working on changing some logic in a module, and some other dev is about to make an integration for a customer which will involve that module indirectly.
He might not be aware of this indirect dependency, so I can give him a heads-up and now we know we must keep in touch over this work.
It's also good in case someone else has any good ideas for solving an issue. Maybe someone knows of a tool or a service which can do the job. Maybe someone has experience on that sort of stuff, so the dev doing the work knows who to ask for advice.
This is the only regular internal meeting I have though. There might be a case-specific one or similar once or twice a month, the rest is just ad-hoc with 1-2 others as needed via Teams or dropping by the office (pre-pandemic).
It was custom made for the tutorial. I didn't release it yet because I mostly focused on polishing the tutorial itself and not the code for the interface. Do you think people would be interested in the interface by itself?
I was wondering the same, this format feels extremely intuitive for the material it explores. Looking at the HTML and the CSS class names I'd assume it was handmade, but it seems like standardizing this format or even generating this webpage format from a repo would be a useful tool. The comment left at the end is ambiguous as to whether it refers to the tutorial or the website as a whole.
You install the OS on a TF (Micro SD) card using your desktop computer and then put the card in the ZeroPi. After booting, you can connect through the serial port or ssh via Ethernet or WiFi, depending on what you have set up.
Insert the SD card into another machine, add a boot and filesystem partition, install OS onto it, mount the filesystem of the SD card, chroot to it, and install sshd.
“Even though I'm never expecting my game to read an empty string in from an s-expression, I didn't want that to be a limitation of the parser.”
This thing is never going to ship. Coming from someone who has written an IDE and wasted a bunch of time on the parser because it was the cool theoretical portion.
That’s fine, I assume learning rather than shipping is the goal here. A fine goal it is.
By the way, the problem is NOT that he wrote his own parser and other homemade tools. This is actually a great thing to do —third party tools usually end up being more trouble than they’re worth. The problem is that he’s ratholing on tiny details that don’t matter.
That's part of some peoples' journeys though:
Learning how to work efficiently. Run into traps and find out again.
I applaud OP with full heart. Especially for stepping up and showing it off.
I don't think I could handle all the negativity you can read here. And so, I'll keep my private projects for myself until I'm done with them. Of course, when I'll be ready to release, nobody will care because I couldn't show it off because of all the negativity.
But on the other hand, I'm not doing this for any of you, only for myself, so I couldn't care less to be frank about what any of you think. I just hope the site being down doesn't mean OP took their server offline just because of all the flak he got for handrolling yet another parser.
I love vim and have never met someone who used it more fluently than me. Yet I find it lacking. I can never get IDE features like code navigation and completion to really work. I use YouCompleteMe like everyone else but it’s just not as good as Jetbrains. It randomly stops working. Parameter hints don’t really work. This is for C++, by the way. The JavaScript situation is even worse.
My dream is also for vim to be the integrated, full-featured software package you describe, but at the moment I find it falls short.
I find CoC to be much better than YouCompleteMe for both C++ and Python. Regardless, it's still not as good as Jetbrains. I don't know if it's a fundamental limitation of the underlying language Server (ccls) or CoC has issues with itself, but i experience random breakages in the autocompletion all the time too.
I love Vim, but since I started working in TypeScript/React every day it is basically unusable (syntax highlighting / code formatting cannot match VSCode) so I'm now running VSCode + Vim extension which is kinda meh, but serviceable.
One of these days I will get around to contributing to a Vim plugin or two to help improve Typescript / TSX support.
I've had a different experience. Neovim + coc-tsserver and a syntax highlighting plugin works really well, and VSCode + Vim extension is unbelievably slow on my machine.
Which syntax highlighting plugin(s) are you using? Do you have syntax highlighting for functional components/hooks in .tsx files / can you share a config? Would love to give it a try.
I have spent many hours trying to get that work with no success. I've searched public .vimrc configs on github using typescript plugins and none of them gave me any type of syntax highlighting that compared to VSCode.
I haven't used VSCode enough to consider myself knowledgeable about it's syntax highlighting or auto-indentation, so caveat emptor.
I use CoC.nvim using the coc-tsserver plugin to get Typescript completion/jump to definition etc, ALE to get ESLint warnings, HerringtonDarkholme/yats.vim (A Typescript syntax, Neovim comes bundled with this, but the bundled version might be out of date), and maxmellon/vim-jsx-pretty for JSX syntax highlighting and indentation (vim-jsx-pretty's auto indentation is not 100%, but it works well enough).
> Yet I find it lacking. I can never get IDE features like code navigation and completion to really work.
Same here. In the end I just gave up and installed Emacs with vim key bindings (evil mode). Took a while to set things up, though, albeit not so much the vim bits, which were fine, but the IDE features.
Vim is fine as a framework for text editing but as an application it's a bit lacking.
I agree. I've been using vim for about a decade now. I love the editing experience. I really dislike the "IDE" experience (plugins, file navigation, etc).
I've been seriously considering writing a new vim clone in go and build what I would consider the ultimate editor. Basically as if vim had been written today.
Onivim might not be for you :) But our project under the hood, libvim [1], might be useful for you to start (if it's easy to create bindings from C in Go).
There's a cool non-Onivim usage of it called Paravim [2] (and the same author also used it for Vim-Cubed [3])
Just to be clear, I was making my comment more in the context of vim than Onivim. I maybe should have said that originally, my bad. I backed Onivim and am keeping a close eye on it. Maybe I won't need to (try to) make my editor :)
Oh them's fightin' words. Actually I have tried evil mode. Although it's been years since I last did. I remember it being one of the better vim emulators out there. I should give it another go.
I find the 'control' part of this iffy. People's actions are caused by their thoughts, feelings and beliefs, but their thoughts, feelings and beliefs are themselves caused by various other things. This is why I think the root question is whether you could have chosen differently. If you could only have ever made one choice, how much control do you really have?
The fact that moral responsibility requires the assumption that people have control doesn't mean people do have control. It just means that people who like moral responsibility (including myself!) have an inconvenient reality to contend with. It means we have to find some way to run a society morally despite the shaky grounding on which we find ourselves.
I would find the compatibilist argument more convincing if it simply said, here are some beliefs that would benefit us if we assumed they were true, rather than saying they are true. We can define free will as 'the assumption that is needed to make moral responsibility work,' and we can even make that assumption in order to have a practical, working framework for moral responsibility, but it still doesn't prove the assumption is true.
> I find the 'control' part of this iffy. People's actions are caused by their thoughts, feelings and beliefs, but their thoughts, feelings and beliefs are themselves caused by various other things.
That trips most people up, but it goes right back to our first discussion about cars also being "not real". If I say to a coworker, "I got in my car and drove to work", and they reply with, "Well that's impossible, because cars don't exist, nor do day jobs", that's kind of nonsense right, because there I am at work, standing in front of my coworker with my car in my parking spot. It's a category error, and it's the same error made when people say that a choice wasn't really ours because it's dictated by the movements of particles.
The fact that thoughts, feelings and beliefs may be caused by deterministic underlying physics is actually irrelevant, which is why Compatibilism is compatible with determinism. What matters is that thoughts, feelings and beliefs counterfactually dictate your choices, and so, by changing thoughts, feelings and beliefs via moral feedback, you change behaviour.
Moral blame is that feedback. The type of control that's needed is simply not the type of control that you're assuming it must be. This is the mistake incompatibilists make as well: they assume the type of control needed has certain logical properties, but these properties have been shown to be flawed.
Now what consequences follow from blame is a completely separate question (of justice), and I mention this because it trips a lot of people up: they assume blame entails punishment, and given they cannot justify punishment when some things are simply beyond one's control, they want to do away with blame itself. But that's unnecessary, because blame by itself doesn't immediately entail retributive justice with punishment, there are plenty of other forms of justice that would serve equally well.
If I’m understanding you correctly, for purposes of free will and moral responsibility, the details underlying the ‘control’ people have don’t matter—all that matters is that they change their behavior in response to feedback that what they did was wrong. In order to give that feedback, we need to take for granted the ‘they did’ part of the sentence. Is that a fair summary?
If so, I think I agree. But it makes me feel like we’re talking about different things. I think we may just have a namespace collision over the phrase “free will” (which I think is part of your whole point).
I guess my question is, if your main concern is being able to assign moral blame, defined as saying someone did something and that thing was right or wrong, why does that require free will? Without it you can still say people do things (in the car sense) and make value judgments about them. Why define free will this way, instead of in the straightforward sense of choice?
> In order to give that feedback, we need to take for granted the ‘they did’ part of the sentence. Is that a fair summary?
"They deliberately did/felt justified doing", but yes that's essentially it, modulo the considerations I discuss below.
> I think we may just have a namespace collision over the phrase “free will” (which I think is part of your whole point).
This is part of what makes the debate so frustrating and confusing for many, because we have religious "free will" with souls and whatnot, we have philosophical "free will" for ethics and moral responsibility, we have scientific "free will" for experimenters (free will theorem), and all of them overlap in some ways, but not in all ways, which leads to considerable confusion.
Incompatibilists think "free will" in all of the above contexts mean exactly the same thing, ie. theistic free will and experimental free will and philosophical free will all mean some sort of freedom from antecedent causes, and that this is necessary for moral responsibility. This is why you'll see scientists and science fans claim we don't have free will, because the nuance between the above contexts is lost.
> Without free will you can still say people did things (in the car sense) and make value judgments about them. Why define free will this way, instead of in the straightforward sense of choice?
Because not every choice is freely made, or an expression of their will. Some people are coerced into making choices, some people have cognitive impairments and so are not capable of making free or willed choices (insanity, dementia, etc.), some people are not of sufficient age for them to understand the choice they're making, and so on. How do we package up all these considerations into a term of art that describes when a person of sound mind and body makes choice freely? Free will.
Compatibilism emerged from the notion of free will in law. Consider all the conditions for legal culpability, and I think you'll begin to see how nuanced this is, and how these considerations are deeply entrenched in how people approach moral reasoning.
This is just mumbo jumbo, because you are not providing any alternative medium for exercise of control than deterministic cause and effect, and so what you are describing is just a veneer.
There is no choice in that case, and so no meaningful exercise of will.
Only if you presuppose "will" to mean "non-determinstic choice", in which case you should justify why that's relevant for moral responsibility.
I've asserted that deterministic choice is perfectly compatible with responsibility, and that our moral and legal reasoning is compatible with this conception.
I do presuppose will to mean something nondeterministic, yes, or the term serves no purpose.
And what you describe empirically doesn't match my experiences. People tend to get strongly morally conflicted when faced with the prospect of determinism because they don't see eg punishment as compatible with a view of the world where people don't have agency over choices.
'Deterministic choice' is not a choice for the person - it is just cause and effect. There is nothing free about it, and no will involved.
The very idea gets people incredibly worked up when you drill down into it.
> I do presuppose will to mean something nondeterministic, yes, or the term serves no purpose.
It serves the purpose of labelling a process of deliberation over a set of choices. Whether that deliberation is deterministic or not is a red herring.
> People tend to get strongly morally conflicted when faced with the prospect of determinism because they don't see eg punishment as compatible with a view of the world where people don't have agency over choices.
So? People struggle to explain how lightning works. The vikings would have gotten quite worked up if you claimed Thor didn't cause thunder. Why does this have any impact on the natural facts of lightning?