jimmy_ruska

There's nothing stopping you from using lisp as a transpiler to generate the java, or different interop glue for the lowest common factor code everyone will surely understand.

The magic was always that it was always an AST all the way down, and you can create and experiment with your own personal semantics and vocabulary, so long as the language is expressive enough to define them in the domain specific way you are doing development. For example a language that is aware of what libraries and databases you're tying together and abstracts the way they interconnect, can compose multiple libraries together without the kludgy plumbing, or autogenerates boilerplate along the way that's required by your build and tests. As long as you generate readable clean Java or whatever, your coworkers won't care how you got there

Somewhat related subreddit https://www.reddit.com/r/netsec

Why would they fix the problem. Every crash is a redistribution of wealth.

When there's a recession, if you're wealthy and have diversified assets you can buy everything at a discount rate during a stock crash and sell when the recession recovers. Meanwhile, the poor and middle class often find themselves unemployed, their savings accounts massively depleted and in a constant crush for cash.

If you're wealthy AND you have the ability to create risk in the market, then even better. You can actually help trigger more "stock discounting" events, and dominate any emerging technology company with your bootstrapped companies while everyone is dying for credit.

Imagine if you invest some money into what becomes a 9 billion dollar valuation company. That valuation is before they've really gone to mass market with their product.

If their product had worked, after a few years the return on investment could have been substantial. It would have been significant loss pulling money out before release to mass market.

George Shultz is 98 years old. It's not like you can take your money to the grave. I would like to imagine he was doing all this for his family. I would also like to imagine that if you have a 9 billion dollar valuation company, and you bring together the right talent, Holmes could have somehow pulled off at least some value added breakthrough.

The real issue was when they started to lie and put people's safety at risk. But theranos had significant social proof. Whatever fraud or risks could have been brushed off as non systemic

I don't see what you can't do with neo4j, neptune, datomic. Neptune offers a sparql interface. You could easily specify an explicit schema. If you wanted to make an ontology that's globally unique you could force it to be defined at a centrally defined application level. If you wanted a inferring traversal, for example applying some type of hierarchy, you could write your own iterator in java in neo4j if you wanted to, or just apply multiple types to the vertex.

In his book programming erlang Joe Armstrong talks about how erlang is OOP in the original sense. You spawn a bunch of light weight processes, and each process is like a living function with its own brain. Pony is a new similar language. Each process can only communicate with the outside world through message passing. You can easily define the semantics of sync vs async, and what to do if something fails. If something does fail, you've decoupled the error handling, and you can respawn processes, even if it was caused by a flipped bit of ram. If you're just synchronous message passing, then it should be just as reliable as java/ruby, and not much slower.

There's still some down sides in that now you can easily get race conditions on human error, you're dealing with distributed systems problems. You have to worry about defining your communication interfaces and keeping them updated, and resilient to change. Message passing has a lot of trade offs.

Sussman of SICP fame gave a similar analogy. Not really about messaging but about biology in general - https://www.youtube.com/watch?v=O3tVctB_VSU

Things like json-ld, microdata, rdfa https://developers.google.com/search/docs/data-types/product

Wikidata also has data in rdf https://wikidata.org/wiki/Wikidata:Database_download#JSON_du...

I wonder what is the killer feature to be had. If you want highly connected data, you can use graph databases like neptune, neo4j, datomic. If you want logic programming, you still have swi-prolog, or something like picat, eclipse, mercury, which can easily model triples or custom ontology. There's also apache tinkerpop and similar which give querying a more object oriented feel. I see prolog can interop with Jena, but if it can, why not parse & query rdf/owl in prolog itself. Can't prolog do everything sparql can.

What is the value offering on apache Jena?

Another option is to use a cloudfront hosted pixel, and have a cloudwatch job to schedule processing of that data every X minutes. This gives you ultra fast edge response time on your tracker, instead of slow lambda + api gateway, but you have to back-process the data. This should also cost less if you have a lot of traffic.

Instead of Google sheets, throw it to bigquery. Or reprocess hourly/daily into parquet then scan with athena.

Sorry, Bill tripped on the server cable

Planes don't just fall out of the sky. Having 2 major crashed on the same model could indicate mechanical defects.

When microsoft faced an issue with statistically increased failure rates they initially played the plausible deniability game ( https://en.wikipedia.org/wiki/Xbox_360_technical_problems#Re... ). In fact this is the only response you will ever get from a public company with short term looking stockholders.

I definitely wouldn't buy that xbox for $300 if I heard similar news reports, but I sure as hell wouldn't buy that $300 plane ticket and bet my life on boeing's words.

Some statistically significant percentage of xbox 360s are starting to red light for customers running a certain model number. Microsoft assures customers that there's no need to panic as this particular model has been reliable for a long time, and it could just be a statistical anomaly. Microsoft is currently investigating the issue but consumers are weary about paying full price for a product that might break.

Substitute xbox 360 with PLANE, substitute microsoft with BOEING, substitute "weary about paying full price" with "dying in a horrible fiery death".

I'm not sure why this is contentious. Be on the safe side and wait for the investigation to complete in case there's some kind of unexpected single point of failure caused by mechanical defects.

Could be to avoid liability?

> Why were you hacked

> Weak passwords

> What are you going to do about it

> We've forced all systems and employees to regenerate passwords and service keys

Now lets try this again without an honest answer

> How were you hacked

> No idea

> What are you going to do? Are you still vulnerable?

> No idea. We'll have to do an extensive audit. No one knows how long this will take. There's not even an inventory of systems or data flow

> Could they have installed backdoors

> No idea

* If it's simple transforms, use cli tools.

* If it requires aggregation and it's small, use cli tools.

* If this is data you're using over and over again then load it in the database and then do the cleaning, ELT.

* If it's 2tb of data and under, still use bzip2, get splittable streams and pass it to gnu parallel.

* If it requires massive aggregations or windows, use spark|flink|bleam.

* If you need to repeatedly process the same giant dataset use spark|flink|bleam.

* If the data is highly structured and you mainly need aggregations and filtering on a few columns use columnar DBs.

I've been using Dlang with ldc a lot because of how fast its compile time regex is, and its built in json support. Python3+pandas is also a good choice if you don't want to use awk.

Hetzner lists VMs that are ultra cheap but then has separate listing for more expensive VMs with dedicated cores. Alibaba does the same.

With these shared core machines, I wonder what the performance reliability guarantees available and how it compares to the dedicated core machines.

Some links worth mentioning

https://www.colm.net/open-source/ragel/

https://beautifulracket.com/

https://www.jetbrains.com/mps/

https://kotlinlang.org/docs/reference/type-safe-builders.htm...

https://en.wikipedia.org/wiki/ANTLR

https://github.com/llaisdy/beam_languages

From my understanding this library takes a grammar and generates a run time interpreter for that grammar. Antlr is much more similar as it takes in a grammar, and generates code you can hook into at any part of the grammar parsing.

Racket on the other hand gives you the ability to hook into the new language, convert it to racket syntax and then compile it. As far as I know racket doesn't give you a simple parsing grammar, and you're targeting outputting racket code if you make a language. Though you could always take racket as your AST and target something like C or LLVM if you want it to live outside of racket.

Racket is not necessarily unique in that aspect, it just focuses on making it easier with tooling. Scala, Kotlin, Elixir are examples of some of the most successful languages https://www.youtube.com/watch?v=du6qWa8lWZA

When you have an erlang distributed app and need caching without having the overhead of converting erlang terms then ETS is the best solution. That's not to say you would want to use ETS instead of redis from a java app.