Standard SQL is a really simple grammar and a very small keyword set - there's basically selecting, updating, deleting, filtering with where, aggregate queries, grouping and joins, and that's like 95% of it. Sub-queries maybe too.
620 karma · joined July 27, 2010
Standard SQL is a really simple grammar and a very small keyword set - there's basically selecting, updating, deleting, filtering with where, aggregate queries, grouping and joins, and that's like 95% of it. Sub-queries maybe too.
Actually, they don't! When you start doing the math about states in a quantum sense (i.e. statistical mechanics), the basic premise is that the available range of states _is_ discrete. Particles are quantized - so they can only possess certain allowable discrete energy levels. The broader laws of thermodynamics fall out of that and appear to be continuous as you scale up to the macro world across a huge number of microstates.
I'm intending to use it soon for some animations to communicate some concepts better over video. The only real limitation I've come across so far is a lack of shape tweening, which would be a very nice to have.
I'm self employed and get the bulk of my income through dividends. As with the example above, I often end up paying roughly the same amount of tax as someone with the equivalent salary would.
The big advantage for me is that I can have a very good year and a very bad year and pay an appropriate (smoothed out) level of income tax across both - which seems fair to me.
The fact that that EU laws can override national laws does not mean that the EU Commission has unilaterally imposed law without consent. Law changes must first must be approved by the Council - comprising heads of state - and then by the EU parliament, consisting of directly elected representatives from all member states.
I know you weren't asserting otherwise - I just wanted to provide additional important context for those who wouldn't otherwise be aware.
Deployment of a service is rarely in practice just deployment of new code to an already provisioned lambda - because that lambda can do nothing in isolation. Instead, it tends to be the lambda alongside an SQS queue and a trigger, and an S3 bucket; or an API Gateway that links an authorizer to the Lambda's code. Because of that, evolution and development of the application tends to require evolution and development of those surrounding infrastructure pieces in tandem.
As a result, managing the infrastructure of your serverless service is often most naturally done alongside the application code itself - indeed, the distinction becomes somewhat meaningless. That also means the engineers developing the service require the ability to own and operate the infrastructure as well. That may or may not be well served by Terraform. It's a tool I absolutely love for mutable, stateful infrastructure, but something like the Serverless Framework or AWS SAM can be a much lower-friction and more natural fit for serverless work.
There are also tools like https://hunter.io/ and https://rocketreach.co/ which attempt to automate the process for you. I've had very mixed results with those kinds of tools, but they're worth knowing about.
The tools and options we have don't exist in a vacuum; you still need good judgement and practice to make the most of them.
Tests (in my opinion) need to run continuously during development. I usually have tests run on file change - either in a terminal window or IDE. They also run on each commit when each branch is pushed.
If you have no option other than to run a test suite that takes hours, that needs fixing. You don't need to run all your tests during development, but pragmatically you need to run enough of them to give you some confidence that you haven't broken things. Some options you might have:
* Separate fast and slow tests (e.g. unit tests and integration tests). Run the fast tests frequently as you develop, and use the slow tests to sanity check what you're doing from time to time
* If there are no fast tests (e.g. everything is almost an end to end or full integration test), write some faster tests just for the feature you're working on and run those. It doesn't need to be perfect; just lay down a start that you and your team can improve on
* If all your tests are fast, but there are just a lot of them and they're so abstracted from the layer of code you're working at you can't tell which are relevant, you can add tracing statements to define a subset of tests that hit the codepaths you're changing. Run the small subset regularly.
* Spilt up your codebase - this doesn't have to be into trendy microservices if your problem domain doesn't support the use case. But you'll almost certainly be able to pull out modules or libraries into separate repos that have their own tests. Version them semantically.
As a discipline, we work across a huge range of problems and I'm wary of making assumptions about yours; but slow tests have a massive impact on how quickly you can deliver in my experience.
In contrast, I've often thought that visual programming tools are much more limited dimensionally, and that's why they can become difficult to manage beyond a low level of complexity: you only have two dimensions to work with.
With the visual programming tools, the connections between components need very careful management to prevent them becoming a tangled and overlapping web. In a 2D tool (e.g. LabVIEW), you could make a lot of layouts simpler by introducing a third dimension and lifting some components higher or lower to detangle connections - but then you'd face similar hard restrictions in 3D.
Text based programs suffer from no such restrictions; the conceptual space your abstractions can make use of is effectively unlimited, and you can manage connections and information flow between pieces of code to maximize readability and simplicity, rather than artificially minimizing the number of dimensions.
Perhaps he should read both simultaneously and finish in half the time...
I'm glad they're putting the effort into making the API simpler and easier to use to address some of those concerns, but React itself has been around for seven years now - the vast majority of existing developments will have been started using versions of React created before hooks were introduced.
In both cases, you end up with non-UI wrapper components to provide the plumbing in a tree of components that would ideally be entirely presentational. That leads in turn to trying to separate presentational vs. container components, trying to avoid nesting any kind of container component within a pure presentational component to keep it easily testable, creating more HoCs in an attempt to separate concerns, etc.
I certainly wouldn't describe React as garbage like the OP - but I think whether it's the best choice is heavily dependent on the kind of app you're building. The design choices it has made comes with significant challenges and trade-offs and we should not pretend otherwise.
I think it's probably a good reinterpretation of the original manifesto that is a bit more fundamental and a bit more direct. I like the concepts a lot.
His insight that Maxwell's contemporaries lacked even the language to fully describe what a transformative idea he had is acutely interesting. Once again language both shapes and traps thinking.
He makes the same point with quantum mechanics as well - that we're constrained by not having the proper language to describe the most fundamental behaviour. I think it's fair to say that point still stands today.
In particular, the "Overturning of absolute time in general relativity" section is very hard to follow, and I suspect would only make passing sense to a reader already very familiar with the subject matter. It has a very stream-of-consciousness feel to it, it doesn't introduce concepts as it moves along, and it makes unexplained logical leaps from one idea to another.
I'm glad someone took the time to start the article and it sounds like an interesting subject; but it could certainly see improvement from someone with the right knowledge.
I think part of the reason we ended up with so many trivial libraries and dependencies in the Node ecosystem was precisely because it is so easy to create and publish packages.
I love Python as a language, but working with the packaging even just to install dependencies is like pulling teeth every time you start a new project - nevermind publishing packages yourself.