dhash

For the silicon chip industry, the Linley Group’s Microprocessor Report [1] is amazing. I know of no better resource for high-end chip news. Here’s a bunch of cut down sample articles [2] and one actual one [3]

[1] https://www.linleygroup.com/mpr/

[2] https://www.linleygroup.com/sample.php

[3] https://www.nvidia.com/docs/IO/55972/220401_Reprint.pdf

There’s also my not alma mater (I didn’t graduate) the Olin college of Engineering

This art style screams Paper by FiftyThree

Academia, just like venture capital is made up of people

I used to think that academia was up to merit, during my teaching days

The only and I mean only reason I ever got a grant is because I called the asshole and asked him to craft it

for me

Kind of embarrassing, but I never actually learned bash well enough to use it even after a decade of programming. When there was only one pair of feet in the sand, that’s where xargs carried me. Everything from web scrapers, to kubernetes admin, I’ve /only/ used xargs to do all of the variable splicing and parallelism that I need.

Stainless [0] does this well for Scala. You augment function definitions and return statements with `require()` and `assert()` respectivley.

[0] https://stainless.epfl.ch/

Iverson notation originated from APL, which was itself born out of the horror that Iverson saw when presented with "standard mathematical notation". Its use of strange, otherwise cryptic notation was influenced by two main themes: it was originally designed on a blackboard, so strange glyphs were normal, and a desire to become unmoored from "standard mathematical notation" in order to strengthen principle 1. of OP - Unambiguity. Casting off historic baggage and canonicalizing mathematical notation under the principles of OP was APL's prime goal, and it does a damn good job of it.

I wish they taught it to math majors.

APL's a wonderful rabbit hole to fall down, and J was my eso-lang of choice last year.

Switching off SBT to Bazel made writing scala so much more pleasant for this exact reason. Builds are 10x quicker, and the caching makes the initial build take 10 minutes, limited only by the speed of your internet connection!

- Yes (Traefik, Fabio, consul connect/envoy)

- Yes, just added CSI plugin support. Previously had ephemeral_disk and host_volume configuration options, as well as the ability to use docker storage plugins (portworx)

- I haven’t personally played with it, but apparently nomad does export some metrics, and they’re working on making it better

Best part is the Oxford devices are _actually affordable_. Illumina has had such a stranglehold on the market - devices start at around 35k and go up into “this is a house now” territory. Meanwhile the Flongle [0] is $99 and the main Oxford device can be had for $1k.

[0] https://store.nanoporetech.com/us/flowcells/flongle-flow-cel...

Lihaoyi mostly authors scala libraries. I switched from python to scala and found many of the things that I love about scala ported to python with this library.

Case classes (pretty .toString, structural equality, .copy, and destructuring), Scala 3-esque enums, f-string interpolations before python added them, pattern matching, and _ based lambdas are the highlights for me.

BioBot Analytics (listed authors of the paper) is a YC company

This looks like what CVC4's SyGuS component is useful for, especially since their optimization criteria is "smallest program"

There’s a YC company [0] already doing this.

[0] https://www.biobot.io/covid19

Oh man if I could efficiently enumerate algorithms across the Pareto front of anything I’d be a happy camper.

Procedures that enumerate Turing machines are generally very easy, or nigh impossible

Iron [1] definitely has the right idea.

Code review comments really should live next to the code, and proper editor integration goes a really long way. Traditional review processes make “just fixing the code” have a very high inertia.

[1] https://blog.janestreet.com/ironing-out-your-release-process...

These are native instruction sets, not a VM. The parent seems to also mean runtimes, which LLVM does not provide

Or Chisel (Scala), which has real, industrial users and a thriving commmunity. RISC-V is in Chisel.

If you want to go really bonkers, there’s spatial-lang which allows easy interop with the Java memory model and heap

Currently doing this for metabolite analysis. Takt time is at 6 hours, not a long way to go :)

others say typestates, but Scala and Haskell have had IndexedStateT for the purpose of typelevel-state-machinery and it works really well with (somewhat lesser) boilerplate and semantics + FP. To me, it's particularly useful for anything resembling a protocol.

Signal based processing is Observables/reactive streams, which provide a sane interface to use.

This is (one of) the problem with new languages: library ecosystem access. It's why Scala/Clojure/Kotlin is one camp of languages and Zig/Rust is in another - both Java and C have a ton of great libraries written in them, with ones that add signals-first approaches via libraries.

Scala/Haskell has the same thing, and it's an amazing feature. The proper type is that of

    trait IndexedStateT[A, B, C]

Which signifies a typelevel state machine moving from state A to state B emitting a value of type C.

I can only speak for scala, but i'm assuming haskell has singleton and literal types as well. Meaning that code like this works great.

    object DoorOpen
    object DoorClosed
   
    class Door {
      def open: IndexedState[DoorClosed.type, DoorOpen.type, Unit]
      def close: IndexedState[DoorOpen.type, DoorClosed.type, Unit]
    }

   val d = Door()
   for {
      _ <- d.open() //works
      _ <- d.close() // works
      // _ <- d.close() //compile error
   }

By my understanding of the article, it uses the borrow/move state to implement the state transistion. Is this generalizable to arbitrary state machines, or only a simple 2-state one?

I have a Linux config I wrote for my desktop manager 8? Years ago. It took me about a week to write, and is themed to my hearts consent. I’ve barely touched it since then, once a couple years ago to add more workspaces, and another a couple weeks ago to change the theme

It gives me the same keybjndings I want everywhere. Linux now feels the same regardless of what distro I’m using, and it’s just the way I like it now.

It’s easy to get suckered in to ricing you’re environment, but you get tired of it eventually and just copy/paste the config around.

Windows scares me at this point, it doesn’t have a nice timing window manger and I inevitably lose what I’m working on in a pile of windows.

I’m a full time scala developer and have had basically no problems taking longer than a day to in moving to the LTS releases of 9+.

It’s probably pretty helpful that the scala ecosystem doesn’t depend much on non-well trodden parts of the JDK

(Full disclosure, i run a YC startup selling to synbio + think that it's undervalued)

The field really doesn't do blog posts, it's a shame.

For some interesting stuff in synbio that's approachable to your prototypical HNer, check out [1], a Verilog-to-DNA compiler that works with small logic circuits. [2] (Not really synbio) but using reed solomon codes to better do High-Throughput Screening. [3] PACE, a way to ask evolution to implement a particle filter for us. [4] A remapping of the base pair 3-tuple to amino acid that maximizes edit distance, filling in the gaps with STOP codons - stopping something from evolving, and [5] some cool people working on wholly synthetic cells.

[1] Nielsen, A. A. K., Der, B. S., Shin, J., Vaidyanathan, P., Paralanov, V., Strychalski, E. A., … Voigt, C. A. (2016). Genetic circuit design automation. Science, 352(6281). https://doi.org/10.1126/science.aac7341

[2] Erlich, Y., Gilbert, A., Ngo, H., Rudra, A., Thierry-Mieg, N., Wootters, M., … Zuk, O. (2015). Biological screens from linear codes: theory and tools. BioRxiv, I(1), 35352.

[3] Dickinson, B. C., Leconte, A. M., Allen, B., Esvelt, K. M., & Liu, D. R. (2013). Experimental interrogation of the path dependence and stochasticity of protein evolution using phage-assisted continuous evolution. Proceedings of the National Academy of Sciences, 110(22), 9007–9012. https://doi.org/10.1073/pnas.1220670110

Esvelt, K. M., Carlson, J. C., & Liu, D. R. (2011). A system for the continuous directed evolution of biomolecules. Nature, 472(7344), 499–503. https://doi.org/10.1038/nature09929

[4] https://www.biorxiv.org/content/10.1101/695569v2

[5] http://buildacell.io/

The first gen ones are able to speak MQTT as well as integrate with AWS IoT core, so they could also fire off lambdas, hit SQS, etc.

The new ones are strictly worse, only able to be bound to a Lambda

Recursion schemes are the FP way of doing the Visitor Pattern. You can get annotations with (coelgot, zygo) which are super useful for tupecheckers, allow the fold to accumulate effects (gana, gcata), or even look into the future of the recursion (futu).

They do get a bit much at times though, since you can compose them easily. Zygohistoprepromorphisms are one example of this.

https://www.ridecabin.com/#!

SAT/SMT hardness regression has come a long way, especially if you can insert profiling information for real instances.

If this is a production model for the cloud, the engineer should have put some thought into the encoding as to express sat/unsat clearly, if possible.

In the general case, sure, to some extent one can construct an adversarial example just as with NN (random 3-sat hardness cliff). Real world formulations of problems are either nice or atrocious IME, discoverable at dev time.

Yeah I wish there was a better logic chart than [1], or at least one that I can give it something in MSOL and it can internally compile it to a representation in one of those logics.

[1] http://smtlib.cs.uiowa.edu/logics.shtml

I write something similar for my own problems. Usually a single instance alone isn’t going to cut it, so we run a portfolio of solvers and treat it like a multi armed bandit problem as to choose which solver with its specific hyper parameters is finding solutions / counter examples faster. A pretty common trick when you do this is to dynamically resize your portfolio with new solvers introduced with a high likelihood of solving fast based off the parameters of other solvers that are solving fast, a particle filter of sorts. This takes care of setting and handling individual solver timeouts, while allowing the user to specify not only a timeout for the whole portfolio, possibly lengthening when new solvers are introduced, but also a max delay between any two solutions.

Either way, you’re still forced to consider if the model can return sat or unsat, or a timeout. If it’s a timeout we don’t swap in the faster code, if it’s unsat then same deal, but if it’s sat we can get some new code to jump to