This post covers my research into open source software licensing and my analysis of real-world open source projects that profit off of open source code via proprietary licenses.
Keep reading and you’ll learn:
- What the difference between a restrictive and permissive license is
- What dual licensing is and how you can use it make money off of open source code
- What CLAs are and the specific clause your CLA needs for use with dual licensing
- Examples of companies that implement dual licensing and how they do it
And of course: I am not a lawyer and none of this is legal advice.
Let’s talk evil. And by evil, I mean money.
Most people thought I was crazy for doing this, but I spent the last few months of my gap year working as a short order cook at a family-owned fast-food restaurant. (More on this here.) I’m a programmer by trade, so I enjoyed thinking about the restaurant’s systems from a programmer’s point of view. Here’s some thoughts about two such systems.
This post details my adventures with the Linux virtual memory subsystem, and my discovery of a creative way to taunt the OOM (out of memory) killer by accumulating memory in the kernel, rather than in userspace.
Keep reading and you’ll learn:
- Internal details of the Linux kernel’s demand paging implementation
- How to exploit virtual memory to implement highly efficient sparse data structures
- What page tables are and how to calculate the memory overhead incurred by them
- A cute way to get killed by the OOM killer while appearing to consume very little memory (great for parties)
In addition to well-known
-Wall, clang offers another interesting warning flag:
-Weverything. While it sounds like a “strictly better” option (the more warnings, the better?) it’s not.
This topic is already well covered by Arthur O’Dwyer’s blog post and the clang documentation.
Arthur makes a strong case against use of this flag. While the clang docs generally agree, though offering a slightly more lenient position:
If you do use
-Weverything then we advise that you address all new compiler diagnostics as they get added to Clang, either by fixing everything they find or explicitly disabling that diagnostic with its corresponding Wno- option.
What I have not seen clearly expressed is how use of
-Weverything is a tradeoff.
The downsides are:
- Increased flag noise from having manually resolve contradicting flags (using
- Friction in upgrading compilers. Upgrading may “break” your existing warning-clean code, because of new warnings that have been added. This means you need to resolve all of those issues (via fixing code, or adding new flags to disable warnings) before officially supporting the toolchain.
- Exposure to “experimental” diagnostics that may be “lower quality”.
However, there are advantages:
- Discovering useful new warnings that you may never have used otherwise
- Finding and fixing bugs during compiler upgrades as a result of these new warnings
Whether you are working on a library or application will also affect your decision.
If you maintain a library (especially an open source one), it makes sense to avoid
-Weverything. You have less control over which compiler versions your users use, and you want to avoid users encountering new warnings if they use a new compiler release to build the library. (Assuming you keep a warning-clean codebase).
However, if you are simply developing an application (especially a closed source one), it may make sense to use
-Weverything. In this environment, you have complete control over the approved toolchain that can be used to build the project, and can have a transition period where new warnings are addressed. There will be more friction for toolchain upgrades, but you may find that the benefits in continually using the newest warnings outweigh that downside.
Thanks to Ryan Brown for showing me this.
If you’re already a 10x engineer, you probably won’t need this article. But for the rest of us, this is what I wish I knew about clang-format as an inexperienced C++ programmer: how to only format the changes in your pull request.
You may have already heard of clang-format. It auto-formats source files for languages including C and C++. You can aim it at a source file and format the entire thing using
clang-format -i file.cpp.
If you’re contributing to a project that is already 100% clang-format clean, then this workflow works fine. But you’ll occasionally encounter a project that is not quite 100% formatted, such as LLVM, osquery, or Electron.
For these projects, the “format entire files” workflow doesn’t work because you’ll incidentally format parts of the files that are unrelated to your contribution. This will add noise to your diff and make it harder for your reviewers.
In this case, you need a way to surgically format only the lines changed in your contribution. To do this, you can use the clang-format git extension. This article will cover the basics of git-clang-format, including a practical workflow that allows for messy development, and formatting at the end.
I took a year off from my tech career and now I won’t shut up about copywriting.
It was probably going to hurt my career. I was fine with that.
The plan was cliché: quit my job, sell my stuff, spend nine months in Southeast Asia. Produce electronic music, read, and maybe code a little. Then find another tech job and pick up where I left off.
Fast forward twelve months. I haven’t set foot on a plane, I created a software product for DJs, and I’ve developed an obsession with copywriting and digital marketing. What happened?
In this post, I’ll share how, despite all expectations, my gap year catapulted my career into a far more exciting trajectory. I’ll debunk two myths society tells us about gap years and share a framework you can use to generate your own life-changing insights, whether you can take a year or a week off. Lastly, I’ll share advice for taking a gap year of your own.
As a founder, picking your market is the most important decision you’ll make. It will impact every aspect of your journey, from product development to sales, and ultimately determine how profitable you’ll be. A good market compensates for poor execution on your part, while even the best execution will struggle with a bad one.
So what goes into a good market?
The key attributes are:
Twitter’s length limit is deceptive. At a glance, it suggests that writing tweets should be easy and quick. This is true for superficial tweets, but does not mean all tweets are written quickly and with little effort.
Twitter is actually a platform for concise writing, and writing concisely is harder than writing verbosely. There are certain tweets I spend a lot of time on and it’s shame to have them get lost in my feed. So I’m storing them here.
Wrote a twitter thread about this:
Are you one of those people that believes their time is their most valuable resource?
I think this is wrong. Your time is valuable, but what’s most valuable is your decision making & creative energy.