It's like a microcosm of how challenging CSS is to get right.
The actual book this website is based on comes from print media. That website is just trying to apply those ideas to the web. And, as we see, not quite getting it right
1,282 karma · joined October 3, 2015
It's like a microcosm of how challenging CSS is to get right.
The actual book this website is based on comes from print media. That website is just trying to apply those ideas to the web. And, as we see, not quite getting it right
http://webtypography.net/2.1.2
I always find myself fighting this on practically every website.
But it makes sense to me, that this should be something we think about in, well, most of our editors as well.
I debate about the measure of code, but I do find 100 to be a reasonable fit for most languages. The problem, is that I want code at 100, and then comments at 66. Oh well.
Once you start speeding past the "what did you do yesterday" topic, you realize how poorly organized communication is on serious topics. A lot of places spin up Google docs or the like to basically make agendas and take meeting notes. So now, unless you have the magic link handy you have no idea where it is. And 9/10 times it turns into a giant mind map of fragmented sentences.
What I'm basically seeing, is that agile, and scrum, grew up in a world of synchronous meetings. To really embrace asynchronous communication needs new ways of organization. And there just aren't strong patterns for this yet.
https://about.gitlab.com/handbook/marketing/strategic-market...
NOTE: I'm not associated with GitLab at all I just found the topic interesting. I don't know of many other projects that actually do things this way, with all the commercial licensed code mixed in with the open source code.
This was kind of an interesting speech I found searching around: https://www.heavybit.com/library/video/commercial-open-sourc...
My hope is that it happens. I haven't seen a lot of discussion from local officials yet, but I could see the new parklets sticking around this summer as a trial, particularly to help restaurants expand seating en route to recovery.
Otherwise, I spent too much of my early career focusing on learning application development tooling, and ignored database systems. Often, a fantastic distributed, networked application is right there in your stack. A lot of good information comes from getting to know how these pieces work, instead of treating them as "magic black boxes".
Many people do not stay focused with longer formats in writing. So adopting a variety of media is a good idea, especially for the fuzzier "conceptual" documents, as opposed to reference documentation.
And I say this as someone who prefers books. I've made the mistake of only using writing, and noticed about half of the team just never seemed to grasp the concepts. Example projects with really short videos helped them a lot.
Who maintains these? Most development teams I've met never bother checking the example code works. 99% of the time, they'll write up a presentation, once, click "record" on the video conferencing software, and everyone says "cool, it's documented". And then, 6 months later, half the presentation is obsolete, and it ends up being even more confusing because as the reader, you have to investigate what has changed since this presentation happened.
I've noticed, if you put some real thought behind maintaining these higher level docs, you don't end up with _tons_ of documentation. And the speed of adoption is rapid. But it takes design, a feedback loop, etc. It's really another kind of deliverable, separate from creating a software product itself.
There's a shift in perspective with possessions. I'm less attached to anything, but at the same time, I appreciate the nice things I own more. And there's definitely a lot more, stronger opinions, on what I want, and what should be a part of my "home".
A bunch of opinions have sharpened unpredictably. Like, I hate grass. I don't want something I have to build an irrigation system to maintain. I like owning a single family home, but I don't want it do be this 'castle' where I'm totally isolated from my neighborhood. I hate big garage doors in front. The front of the house is for the doorway and a porch. The car has its place to the side.
Had I not had to rebuild from scratch a couple of times, not sure I'd be this focused.
Supporting distribution for all the different kinds of Linux package mangers alone isn't easy, and you take in how macOS and Windows do things, I'm not even sure where you start.
It's kind of sad, but there's multiple walled gardens in play here. I mean, Java's been around for 25 years, and it's just starting to get tooling for making OS installers for applications (jpackage).
So, programming toolchains just invent package management that is easy for everyone to use. Everyone needs a problem solved today for multiple platforms, and it's not like OSes are working together to make this easy.
Personally, I've come to prefer vendored dependencies with the sources, and building scripts around vendoring, separating the build from dependency distribution. But not a lot of programmers are comfortable with this. It's not a common practice, and the most popular version control system (git) isn't very great with binary management.
But my approach to games is very similar - once I play it through I rarely go back to it. Outside of some strategy games like Civilization, of course.
It really feels like Stadia could have led to a new kind of gaming market, but they didn't. And they don't seem to have the leadership to make that happen.
I'm reading between the lines here, but, I'm assuming you've setup your tooling to enforce this. As in: the various projects in the repo don't just optionally decide to have external references, i.e., Maven central, npm, etc.
This puts quite a lot of "stuff" in the repo, but with improvements like this article mentioned, makes monorepos in git much easier to use.
I'd have to think, you could generate a lot of automation and reports triggering out of commits pretty easily, too. I'd say that would make the monorepo even easier to observe with a modicum of the tooling required to maintain independent repositories.
For example, the decision nodes will be somewhat vague, e.g., "Does event have good location data?" The details of that question are actually very complex, covering multiple fields from different data sources. But the gist is very much "if we don't know it, we're going to then hit this location subsystem". This is in a processing chain that's pretty complex, so, it's just kind of a basic guide.
Most of the consumers of these docs are often engineering managers who want a picture of the system, but aren't performing real engineering analysis.
I don't use them for detailed technical analysis. Usually, that just involves code.
I find dataflow diagrams can be useful, but even those can be overwhelming, depending upon the audience.
Ultimately, I don't think you can just talk about diagramming without the context in which you're using the diagrams. I rarely use diagrams with technical reference documentation these days. I use them with high level explanations or tutorials.
1. System architecture 2. Flowcharts
NOTE: I don't try to mix the two. Architecture diagrams are the what, not the how. I find a lot of people try to mix them.
Beyond this, sequence diagrams are useful.
I use these for explanatory documentation, mostly. Like, we have a "architecture guide" for each service we maintain, that usually contains a system architecture diagram, and maybe a flowchart of the "happy path" processing. But these are simplified versions things... like, I usually leave configuration details, like networking and access control out of the architecture guide, and just focus on "what services are interacting with each other directly".
Also, LucidChart has an "AWS import" method, that actually works well, but can be a little like drinking from the firehose. It's a solid tool, but mostly as it's own kind of reference document, like, API documentation for your AWS stuff.
> Explanation should do things that the other parts of the documentation do not. It’s not the place of an explanation to instruct the user in how to do something. Nor should it provide technical description. These functions of documentation are already taken care of in other sections.
Where UML goes wrong is that it tries to be a very detailed technical description. Usually, you just want a reference guide for that sort of thing. And reference docs are rarely maintained manually, at least not with any accuracy. I've yet to find a good system that can generate diagrams for technical reference that's usable.
It's hard to say what fits and what does not in a diagram, because it depends on the point you're trying to make. But I usually find that "explanations" are really tricky to get right. UML's a handy place to start thinking, but you're almost always going to cut out a lot of detail to make an explanation easy to understand.
Newcomers get no real guidance on what to do. What do you install? It can be any of a number of different vendors. How do you deploy? The official documentation hasn't been updated since Java 8: https://docs.oracle.com/javase/tutorial/deployment/index.htm.... It still mentions applets! (Which are going to be removed soon.) IMO, all projects should be using jlink and shipping a slim runtime they've used to test against (https://docs.oracle.com/en/java/javase/11/tools/jlink.html). There's basically zero documentation on how to use this for non-modular applications, and you have to find and apply non-official plugins to get that work done. I continue to see most deployments using the entire JDK which, honestly, has been unnecessary for three years.
Nobody really knows what they mean with "OpenJDK". They might be talking about some distribution based on the source code. Or, they might be talking about a download from jdk.java.net. Or they might be talking about installations from Azul, Microsoft, AWS, or any number of ad-hoc vendors because the name is unlicensed. This is a big deal, because I've had team matest install "OpenJDK" and actually end up with ad-hoc builds that weren't tested, and had random bugs.
Professionally, I've ended up having to deal with fixing landmines because Java devs tend to not learn the intricacies of their frameworks as well.
The technology is still going strong, and is moving faster since the modularization. Loom (https://blogs.oracle.com/javamagazine/going-inside-javas-pro...) will be a big deal... but I wonder, will most devs practically understand how to take advantage of it?
Even today, it's contributors come from all over the place: https://www.postgresql.org/community/contributors/
I agree with the final statements of the article:
> Open source-licensed projects with a non-profit home, neutral trademark ownership, and multiple significant contributors are less likely to face pressures to relicense. Projects that are the main revenue generator for a ‘single source’ for-profit company have different dynamics.
To "protect" important projects, the more we can find a way to keep them running via a non-profit structure would probably help most of them.
This is why I think the Rust Foundation is an important step for that language, and gives me optimism. It's the right approach: basically, become supported by multiple businesses, effectively not putting all your eggs in one basket. I hope the Rust Foundation succeeds and becomes a paradigm more popular than "try to build a business on my open source project" concept.
https://github.com/VMwareFusion/vctl-docs/blob/master/docs/g...
Looks like it supports doing some kubernetes stuff using a `kind` cluster.
I've had pretty good experiences with Fusion, so, yeah, there's some real Docker alternatives up and coming. I think Docker's great, though, and I feel that we'd never have seen a `vctl` on a mac without it's existence.
I just haven't any evidence that the LSP is creating a disruption, which is what the article is asserting.
Right now, it seems like you still have Microsoft as the main driver of the VS Code ecosystem with a few other contributors, and JetBrains really drives a lot of its ecosystem, with a few contributors. Not really seeing much of a difference, and, it doesn't seem like the products or business of JetBrains is significantly challenged by VS Code.
I mean, I haven't heard anything like Google deciding that VS Code will replace Android Studio, right? If the LSP was a true disruptor, I'd think that after a few years, that would be true. I'm sure eventually there will be more and better support for Android development in VS Code, but that probably won't displace Android Studio much.
This whole argument that VS code takes over seems to be assuming the Language Server Protocol and Electron is a vastly superior ecosystem. I haven't seen any evidence of this being true. It's probably an improvement over the older Visual Studio ecosystem, though.
Sure seems like this argument is just another version of, "Well, it's Java, so it's enterprise/corporate/boring".
They're both open source ecosystems, and that's great. And I'd rather work with the JetBrains or VS Code ecosystems, then say, Eclipse, even though all of them are open source. (I haven't met many Android devs yearning for the Eclipse-based Android development environment.)
Edit: to clarify that open source commment
https://www.propublica.org/article/inside-turbotax-20-year-f...
Most Americans are simply unaware that other countries have dramatically simplified this problem. It's amazing how many have magically assumed this was because this was some socialist concept and the immediately launch into "oh, but how much more in taxes are you paying? pfff."
My recommendation for anyone new to the area, is the streaming systems book: http://streamingbook.net/, which came after two excellent blog posts: https://www.oreilly.com/radar/the-world-beyond-batch-streami..., and https://www.oreilly.com/radar/the-world-beyond-batch-streami...
Basically, if you have an unbounded data problem, and you might have something that is _practically_ unbounded, that book really helped me gain insight to describe what we used Kinesis for (which is really similar to Kafka in a lot of ways).
Thinking about event vs processing time, ordering and windowing requirements, etc, were really helpful in thinking about my own data problems.
In the end, the author of this article claimed that WeWork just simply didn't have much of an unbounded data problem. Which I generally agree with. But simply saying "you can do this in PostgreSQL" isn't really a great takeaway, and, it really feels that was the message being reinforced here.
https://www.iii.org/fact-statistic/facts-statistics-auto-the...
> The Honda Civic was the most frequently stolen passenger vehicle in 2017, with 45,062 thefts among all model years of this car, according to the National Insurance Crime Bureau (NICB). The bureau notes that most of these thefts were older models that lack the anti-theft technology of today’s models. In fact, there were 6,707 thefts of the 1998 model year Civic, but only 388 of the 2017 Civics.
But, never underestimate the sheer incompetence of car owners:
> More alarming is the finding that there were 229,339 vehicle thefts with keys or fobs left in the vehicles between January 1, 2016 and December 31, 2018.
I don't know how many times I've read a nextdoor article that states: 1. the car was stolen or broken into, but, 2.) they didn't lock their 90s-era Honda.
I'm very far from a Maven specialist, though.
I suspect with Maven this would require some plugin work.
I've had to fight to actually hold post mortems, and every time I've done this, the manager ends up asking, "hey, can I share this?"
So clearly, there's value, at least when we've done them.
I'm amazed at how few places even perform a complete feedback loop. It's just, "when can you get this done?" and, "is it done yet?".
Personally, I've stuck with Gradle, even though I'm not really happy with it, mostly because of these features:
1. Composite builds - https://docs.gradle.org/current/userguide/composite_builds.h... 2. Dependency substitution 3. "local" plugins, i.e., stuff in `./buildSrc`
These features let me combine projects defined in multiple git repositories in a "workspace" project. Then IntelliJ can read all these projects, and it magically substitutes my local version over a specific version. Ergo, I can have multiple libraries, edit and debug them and and application code. When it's time to commit, I push them up in individual MRs back in GitLab - And I could swear GitLab was going to make some kind of multi-project MR possible at some point.
So, the "workspace" is generally for development, then we use GitLab CI for each project independently, for a "formal" versioned approach. It's quite nice.
In any case, I'll typically work with a pretty broad set of apps and libraries in a single workspace, typically between 15-30, and Gradle and IntelliJ handle this just fine. Our Maven projects with fewer modules never seem to get things working as smoothly ironed out - I suspect it's something wacky going on with the build.
So, while Maven allows build composition, but doesn't really have the dependency substitution concept, useful for local workflows. Also, it just doesn't seem to perform as well, especially with the IDEs we've been using. I can't explain it, haven't investigated it, but then again, I've found a solution that works.
https://www.mongodb.com/licensing/server-side-public-license
I've heard of this in a couple of other places, I'm not aware of a common approach just yet. And I'm not sure how it's played out.