brianm

Huh, I got cottage core, not dystopia!

Not really -- non-profit boards are usually volunteers, even ion the non-profit has revenue used for operations.

I've seen a couple of cli apps recently take the path of "config file is long form arguments, minus the --, separated by newlines, overridden by actual arguments", so if you were doing `dsh` (which doesn't support this) it might look like

    verbose
    show-machine-names
    remoteshell ssh
    forklimit 4

I generally use [click](https://click.palletsprojects.com/en/stable/). Need to try typer now :-)

A coworker, once, had a cool idea to use Taylor Series to encode histograms for metrics collection. Basically a digest method akin to sketches or t-digests. We wound up using t-digests as Stripe (iirc) had a good OSS implementation at the time, but using Taylor Series has been lingering in my mind ever since.

I'm not sure how this applies in softwoods (like the hemlock & fir type stuff usually used in construction), but it is not really so obvious that slow growth (tight rings) is better than fast growth (wide rings) in hardwoods. The fast growth wood is usually much less likely to shatter or split under strain -- which for some purposes (anything delicate, or with staked construction such as Windsor chairs, basically stuff which needs to bend some under use) is preferable.

I'd need to break out my [Hoadley](https://www.tauntonstore.com/understanding-wood-2nd-edition-...) to confirm, but my belief is that you are trading modulus of elasticity for modulus of rupture.

Introduced by mutual friend

20 years ago I was in a very similar position, but it was perl I was writing instead of python :-) This advice is therefore dated, and exhibits survivor bias, but it is what I know:

1) Shore up your formal learning in at least data structures, databases, and architecture. I took night classes at the local community college, but there may be better ways now.

2) Find something to hack on where you get useful critical feedback both on your design approach and code. Critical feedback on your work hurts, but it is necessary to grow. Open Source can work well for this, as long as it is some project you actually use for something real(ish) so that the contributions you make are driven by your actual usage.

3) Network -- join local user groups, go to meetups, be curious and engage with people there. Folks are usually thrilled to rattle on about the stuff they are interested in, listen, ask questions, care.

If you have a decade of experience in some domain, look for ways to leverage that experience in a transition into tech. My first job in this career was as a technical writer and trainer, because my previous career involved a LOT of writing, and I was good at it. My next job was at a company where I had a lot of domain expertise in their target market, so despite having limited technical experience in the role, I brought a bunch of domain knowledge to the table.

Learn both, you will eventually have to anyway, and it won't hurt your learning curve, in fact will probably help to see similar ideas implemented and expressed very differently.

beelink or minisforum have you covered

https://skife.org/

Kind of on pause for last few years, but not dead :-)

Apache uses [APR Versioning](https://apr.apache.org/versioning.html) which I think had a big influence on semver, fwiw

Most companies, in my experience, don't actually know how to make use of Staff+ engineers. I spent years at a medium sized public "tech" company just trying to help the company change engineering enough to make use of these folks, and we go to a place where we could... mostly.

FANG and FANG-model (anyone copying FANG engineering/product model) companies do it well and have the bulk of success cases. Look for engineering-lead companies first, product lead companies second.

A key question when interviewing is "how is the roadmap established?" You want answers where senior leadership establishes goals (strategic or metric), product provides their understanding of opportunities, and engineering decides what to actually do. Even then, there will be the common failure model of EMs doing the roadmapping, not senior (staff+) ICs, but you can tease apart how that works, as it is always going to be a mix.

Hah, wave. That is a name (latchkey, not jboss) I have not heard in a very long time :-)

I was thinking of the EJB 1 & 2 era xml wiring of all the things.

This is... EJBs. It is probably less painful to use, but the model is pretty much the same. Fascinating.

Yes, but it mainly has come up when combining libraries and releasing something else as OSS. For example, the ASF has a good examination of the effect of combinations with the AL2: https://www.apache.org/legal/resolved.html

glitter

It predates Groupon, was actually started at/around Ning (if anyone remembers them). Groupon hired a bunch of the core folks at the time they decided to adopt it.

Thrift and GRPC fill that niche nicely.

The title is misleading -- one developer (a major one, mind you) is stepping back from offering free community support. This is not "Apache PLC4X" announcing an end of community support, it is one of the core developers announcing he will be doing so.

This looks brilliant, but...

Sending CLI input data, even just the root command, back to Fig is going to be a deal breaker for a lot of companies. Too high a risk :-/

If you don't need that data, don't collect it. I am sure it will lead to interesting analysis, but it will also leak a lot from companies who are unwilling to let that stuff leak.

mod_python (http://modpython.org/live/current/doc-html/handlers.html#pub...) as a service!

The technical heavy lift is rarely the success determinant, so having a company implement half-baked (enough for internal use, but without the edges polished off that are needed to support it with external customers) versions of N related (but not yet mature) technologies is pretty normal (if they are full of good engineers) and getting advantage from it.

Most of the time these implementations are too tightly tied to the rest of the company's infra to be useful standalone. When one of those companies succeeds a common pattern is for engineers to cash out, leave, and build a new startup around one technology from the success story.

I would not be surprised if this is one of the forces that drives the consumer -> infra -> consumer -> infra cycle. A consumer wave leads to inventing lots of interesting but bespoke infra while it is growing like crazy. When it plateaus, folks spin out the interesting infra bits until the next consumer wave (generally larger) starts rising.

can VSCode connect to a remote server and connect to remote docker containers?

Yes, it can. https://code.visualstudio.com/docs/remote/containers-advance... talks about setting it up.

This is cool! At a previous company we got a lot of mileage in debugging and ad-hoc tasks by exposing various things as filesystems. We mostly did webdav, but NFS is way better from a client transparency perspective. For many folks find, ls, and grep very much beat curl and jq.

I doubt it, the dependency chain is pretty big: https://gist.github.com/brianm/066797531d8cc1f1c6c563ea8db7b...

I was curious about this, so applied the easy ones for an existing tool (https://github.com/brianm/wsf).

This was not an exhaustive test of optimization combinations, just a single stack, but the results are interesting!

To read the table: default is no changes in the release profile, ie:

  [profile.release]
  # opt-level = 'z'
  # lto = true
  # panic = 'abort'
  # codegen-units = 1

Results:

                       as generated    after cargo-strip
  default              8675776         5069328
  opt-level = 'z'      9023200         4676112
  lto = true           5943312         3586584
  panic = 'abort'      5062456         3135928
  codegen-units = 1    4747000         3013048

  rustc 1.43.1 (8d69840ab 2020-05-04)  
  cargo 1.43.0 (2cbe9048e 2020-05-03)  
  cargo-strip - reduces the size of binaries using the `strip` command 0.2.2  

-Brian

I really like this! I particularly like that it is oriented around a useful workflow, rather than for just "small code at rest".

It looks like it parses the schema to find type information (2 minute skim, so please forgive me if I got it wrong!) Hoe does it handle schema changes?

Unifi controller on a pi zero might be a bit painful on the memory front. It wants the controller (java app) and mongo, both of which like to eat up memory.

FWIW, I have seen (and have recommended) designing a number of applications with the spreadsheet as their front end. This works particularly well with google sheets, given its reasonable API. It is way richer than anything you will quickly build, is designed for mucking with tabular data (and makes it relatively easy), and it turns out a ton of applications are basically interfaces on tabular data. Hey hey!