wkz

Technically, sure. What is the moral distinction though?

> Yes. I will watch it for free as intended, nobody posted the content to be YouTube premium only, so I won't pay for it, I will watch the sponsor segments though.

Fair enough, but the grandparent's point was specifically about circumventing the ads, no? At least that was what I was addressing.

> It's like paying the mall because the comic book shop I like is inside the mall, so that the mall can finance and advertise all the things I hate in life, while also killing the exposure of the comic book shop.

But your fine with some percentage of whatever you spend in that store going back to the mall in form of rent? Seems like an accounting detail to me.

> I won't pay YouTube though, [in that case I will unilaterally decide that I can consume your content free of charge], sorry not sorry.

For clarity, I just added the quiet part.

And once you've used that API to download and tag everything, what tools do you use to interactively view the results, run search queries, apply patches to local trees etc?

If your on-disk format is an Mbox or a Maildir, you can use tools like notmuch and its emacs integration to do it.

Now don't get me wrong; I love GitHub. I host all my projects there, and I prefer PRs+issues to mailinglists in almost all cases. But for massive projects like Linux, a mailinglist (and associated tooling) scales better, in my opinion.

It's easy to forget the maintainers' side of this.

Yes, most contributors will prefer opening a PR on GitHub as apposed to mailinglists. But imagine instead that you are David Miller, and it's your job to consume the absolute fire hose of patches and messages related to Linux's networking subsystem. Would you rather wade through the hundreds of messages and patches coming in every day using either GitHub PRs and issues or email?

I would choose email for one simple reason: It's easier to script.

Even as a small-time contributor and observer to that space, I couldn't even imagine trying to keep up with everything going on if I couldn't bulk download, filter, tag etc. As a maintainer it would be excruciating.

IIRC, I believe that the difference traditionally was whether to pass the input through the preprocessor (.S), or not (.s).

Not sure if it makes a difference on modern toolchains.

Great writeup!

Especially liked this nugget:

> (NOTE: This grammar is 704 bytes in ascii, 38% larger than it's implementation!)

If they really don't think that they need to comply with any license, then why not include all private repos in the training set? Could it be that they're worried about legal repercussions, whereas OSS is easier to (ab)use for this purpose because there's much less legal muscle behind it?

It is also very telling that they have not included any of their own proprietary code in the training set. If it's merely suggestions that are generated, why not also train on the NT kernel? Office?

While it might not be a special case exactly, you most likely won’t see /bin/[ being executed either. Typically your shell will implement it as a built in command. Because as you say, spawning processes is expensive.

A clear case of Rob Pike’s 3rd rule of programming:

https://users.ece.utexas.edu/~adnan/pike.html

Xenomai uses this model, I believe. It is written in C, but I don’t see why you couldn’t do something similar with Rust.

Not sure if it qualifies as a GUI, but I’ve found magit increases my productivity with git.

For one, I think this would be cumbersome from a debugging perspective. All of the address-to-source-mappings in your DWARF section would point to things like "lib.c:237652" instead of "lib-module.c:347".

It also means that you're effectively linking all you dependencies statically. In some cases this can be a plus, in some cases a minus. I think having the choice is important though.

I imagine there are lots of other parts of the toolchain that would have to be updated to support this workflow. Seems like a lot of hassle for something that, though at times complicated, mostly works.

I feel like one alternative is missing from the list:

  fp = fmemopen(buf, sizeof(buf), "w");

  fputs("one", fp);
  fputs("two", fp);
  fputs("three", fp);

  fclose(fp);

Not sure how it performs, but it reads pretty well IMHO.

I never argued that it was. Though, "embedded" covers a wide spectrum of systems. For microcontroller-based projects, then no. For bigger SoCs paired with hundreds of MBs of FLASH/RAM it can be very useful.

My original point was that claiming that Linux is partially modular while RIOT is fully modular feels like a stretch to show N lines of red crosses and orange circles, followed by one line of only green check marks.

Linux's FLASH/RAM requirements are enough to disqualify it from projects targeted by RIOT, IMHO. No need to make dubious claims of limited modularity.

I disagree. Sure, it is a monolith as apposed to a micro-kernel, i.e. everything in the kernel shares the same address space. But it is highly modular in that most drivers and filesystems can be dynamically loaded/unloaded.

TIL about protothreads. Thank you. That does indeed look hair-raising!

The OS comparison table leaves me somewhat puzzled.

Contiki's "C Support" is listed as "partial" without any explanation. What does this even mean? It seems to me that this should be between you and your compiler.

Linux is supposedly "partially modular", whereas RIOT is fully modular. That's a bold statement.

I get that they are trying to differentiate their product. But without motivations, statements like these sound a bit hollow to me.

IHMO, threads are mostly useful for scaling a workload beyond the capacity of a single core. For all other types of concurrency problems, a single thread of execution using some kind of event loop is usually a better fit.

I think you have to put his principles in a historical perspective. Sure it sounds somewhat extreme today when OSS dominates many layers of our business stacks. But assuming that the industry would have naturally seen the OSS light is far from a given IMHO. I think copyleft licenses where a very important springboard to start the virtuous OSS cycle.

Thanks for the plug! :)

Please allow me to follow up with one of my own https://wkz.github.io/ply/, where you can see some examples and read through the manual.

I'm currently working on a new version which will be easier to extend and will have a full C-compliant type system. Still tiny though. Hope to have a commit worthy of a git tag soon. :)

Yes, I agree with it being that way. I just think my brain parses the origin as being the corner that is closest to the "0" label. Therefore, if the labels where below the plot, there would be no parse error :)

Sure thing:

https://github.com/Netflix/flamescope/issues/1

Wow, great visualization! Thanks for sharing the source.

A minor suggestion: For the first part of the demo i was thrown of by the fact that each second as laid out bottom->top. Maybe moving the time labels below the plot would provide a visual cue for the direction.

How would this be different from &? It is also a unary operator and && is a different binary operator.

'||' and '&&' are distinct tokens in C as far as i know, i.e. not handled as two consecutive '|'s or '&'s.

So your example would unambiguously be parsed as "a to the b:th power". Whereas the other case would need explicit parens:

   int c = a * (*b);

Similar example for &:

   int a = 1;
   int b = 1 && a; /* 1 LOGICAL_AND a */
   int c = 1 & (&a); /* 1 AND address of a */

The argument was not that freedom of speech follows from democracy. You could theoretically have an authoritarian rule that allowed unfiltered criticism against it. The argument was: not allowing freedom of speech is always wrong, independent of the type of governance.

I agree that democracy in itself does not guarantee rights for minorities. It depends on the majority adhering to a moral system that enshrines human equality. We know that this system can break down, a population can agree to subjugate some of its members. I would still rather put my trust in the majority over in one person and especially in a system that allows me to replace the government after some period of time.

The same argument could have been made about Europe not so long ago. I think one difference is that back then the playing field was more equal. Military power was roughly equal to the number of people you had fighting on your side.

Fighter Jets, Aircraft Carriers, Tanks, Drones, Nukes changes that to military power being equal to your economic power. Meaning that authoritarian governments are much harder to displace if they have enough economic power.

> Their lives are largely unaffected.

This might be true for a large portion of the population. That does not justify treating the rest as enemies of the state. Not allowing people the freedom to speak their mind is never moral.

The one online tool that I use for this kind of work is Woboq Code Browser. It's only C/C++ projects and not many are freely available. The Linux kernel is though and I spend a lot of time in that code base. glibc, gcc and llvm are also available.

https://code.woboq.org/