> One can create new languages fit for the purpose of a given class of problems and thus reducing size of codebase 10 to 100 fold
interesting, thank you for sharing.
Could I transpose your thought into:
--
Solutions (or large scale programs), should not be written
in a general purpose language.
Instead, there should be core domain language (solution DSL) developed (using a general purpose language)
and then the solution should be developed using the solution DSL.
Here's another unpopular opinion: Not much of the value of a DSL is in the syntax.
That is, I'm trying to write a program to do X. In, say, C++, I create data structures and functions as building blocks to write the higher-level functionality of the program. That's my "DSL" - just classes (structures and functions).
In Lisp, I can go further. In creating a DSL, I can not only create function (and, through functions, data structures), but I can also create syntax. This may let me write less code, and may make the code I write clearer.
My assertion is that, while that's nice, most of the DSL is actually the functions and data structures. The syntax is sugar - say, maybe 10% of the benefit, but not more.
> My assertion is that, while that's nice, most of the DSL is actually the functions and data structures. The syntax is sugar - say, maybe 10% of the benefit, but not more.
I don’t know, thinking of some DSL’s like HTML or SQL, syntax seems to be a really big part it.
It isn't immediately obvious that it is, to me. Could you expand on that?
For example, what works for html is basically the dom (data structure) and its functionality (the functions). There are others ways of creating and working with those than the specific html syntax. For example, haml. Or you might say, jsx, or elm,is also such a syntax for the same data structures.
Touché. I understand better what your saying. But even though the syntax changes, we always have some specialized syntax for using it. But it does make it seem like the data is more important since that is what stays the same.
Most constructs in most languages are syntactic sugar + varying degrees of enforcing constraints. The core you need to e.g an object oriented system or first order functions or any other higher level construct is tiny. You can do closures in C for example (done it). But it gets ugly and unreadable and hard to follow.
Syntax matters hugely in making the expression of an idea concise and readable.
Blocks in Ruby (or Smalltalk..) for example are pretty much just syntactic sugar over closures, are just syntactic sugar over functions, but both makes a substantial difference in ease of use, which again affects how people tend to think about problems.
E.g we are much more sparing with closure like constructs in C, even though nothing prevents it, because it is tedious.
I use FreeBSD when developing non-mobile work (which is mostly java backends + JavaScript react).
My environment is
- Hyper-V on windows laptop
- FreeBSD 12.1 as guest (zfs)
- FreeBSD packages I use for devel (installed simply with its standard 'pkg add') are: InteliJC, vscode, openjdk11, postgres12-server, node12, tmux
- Desktop env is: xrdp (to allow remote desktop into the VM), wmaker (window manager and wmakerconf to config it), qterminal or lilyterm
So I just use Remote Desktop from windows host, into FreeBSD VM using XRDP and just run like that.
I connect using 24 or 32 bit depth (via RDP protocol) and tend to run Darkish/pastel colors themes in Visual Code and IntelliJ.
---
I know this is not an ideal setup, but lack of support for mobile dev (android at least) prevents me from using FreeBSD directly on hardware...
When Running on native hardware, without VM, I tend to use Pop! Linux because of how beautiful it looks, on HiDPI or regular screens, and it is relatively easy for me to use, as somehow that window manager setup does not get in my way
I also usually install emacs 27 or 28, but those require a binary package download from
Article mentions that server-side rendering was needed for SEO (Search engine optimization) and first-page load speed
(normally server-side rendering first-page loads faster because it is pre-rendered (and often cached) ).
>"...
SEO was a very important consideration — we had full-time SEO consultants on staff — and we wanted to provide the best possible page load speed, so server-side rendering quickly became a requirement.
..."
With regards to:
>" Rudder runs as a single go binary with Postgres. It also needs the destination (e.g. GA, Amplitude) specific transformation code which are node scripts. "
what would be a recommended approach, if I would like to keep the data internally, and not use external Analytics engine?
Thank you, my understand was that S3 is also 'external' (that's AWS service).
What I was hoping/looking for is something where another tool lightweight tool that can be installed alongside Rudder, that can use PG instance (may be just different db within Rudder's instance or just different schema).
For a light weight, end-to-end solution (including analytics) that can 'grow' with needs.
For many small self-funded startups that care about privacy a combination of following challenges exist:
a) need self-hosted solutions that require minimal footprint (because data, even anonymized, is hosted on self-paid VPS instances )
b) need to use solutions that do not require initial purchase/investment, but yet can scale out (both technically, and in terms of support) when/if commercial model of the startup becomes more successful
c) need to use solutions that are not heavy VC backed, because those typically do not have stable engagement model (as VCs rates of return demand, typically, changes in initial service/open source model, while self-funded startups are typically much slower growing (and slower in committing to buying expenses))
d) need self-hosted solutions to cover lot of ground in one (so that the learning curve, and time needed to integrate are minimized).
In next 2 weeks, we are releasing Redshift as destination. After that, we have PostgreSQL destination in our pipeline. You can configure it and capture everything there.
If you prefer that to be in files, you could setup a minio server on your VPS instance. It's coming in next weeks too.
https://github.com/minio/minio
We would like to understand your preference on this so that we could align our next set of destinations.
Please drop an email at sumanth@rudderlabs.com or join our Slack/Discord channels.
One can also use D (now part of GCC).
D with its better dialect allows one to not use D run time libraries, or even C++ runtime libraries. A developer can just choose what C libraries they want to link with.
In this mode, no GC is provided, so a developer will be using manual allocation.
With upcoming D's dip1000 feature, it will be able to do rust-like borrows checker at compile time (or at least this is my understanding). And that capability will be available in betterC mode as well (not just for full blown D).
The code in betterC can use generics and other advanced features
We are using NGINX with its core Stream module to receive HTTP/2 encrypted traffic, and loadbalance it (with random or least_conn) algorithms -- to each of our backends.
Traffic stays encrypted end-to-end, and it remains HTTP/2 (because the Stream module works at TCP level, not http so it does not care http/2 or http/1 is used).
It seems that in the ticket [2] that you mentioned, the commenter at the end is asking exactly for this. And that works well.
It is called often 'pass-through proxy'.
The article here explains how to set it up
We loose information about the Web-browser's IP address at our backend.
For for privacy-enforcement reasons, we actually do not want to have it at our terminating points (our backend apis).
And also, if we ever need it -- I thin this can be enabled with the proxy protocol.
Thus it's just a plain TCP proxy and cannot route the traffic intelligently (based on Host or path) nor cache it. Following the same principle it could be said that haproxy has been supporting end-to-end H2 since version 1.0 long before H2 even existed!
With haproxy you can combine any set of H1/H2 on any side (protocol translation). It can even dynamically choose H1 or H2 depending on the negotiated ALPN the server presents, just like a browser does!
Thx. Yes, NGNIX will not be able to balance HTTP/2 traffic based on HTTP headers. But HAProxy 2.0 can.
In our case, we are not un-encrypting at the load balancer, so we cannot see the HTTP headers anyway. Instead we use NGINX to load-balance based on TCP-level info.
Well, if Huawei would say
a) here is our store
b) your app will be marketed to Chinese population (as long as your backend servers run on Chinese infra)
then, I think they have a chance to attract app developers.
Otherwise, I doubt it.
For Chinese market, Huawei don't have anything to worry about. It is likely gain more "Chinese" market share from this.
For the rest of the world, it would be completely different story. It is hard to imagine Huawei won't loss huge market share from the EU and rest of the world without Google's Play Store.
Surely, just cancelling debt will always increase cost of service (I cannot come up with a historical example where this is not the case, but happy to be corrected).
However, this gesture is not a policy, and just a really nice gift and expression of altruism.
Also... since you mentioned it, I cannot believe how little teachers are making, including their pension guarantees (in US and many other countries) -- for the effort that many of them put in -- this is just a disgrace.
I wish, there would be a way for exchange safety/tenure guarantees for significant pay increase (eg at least double). And let the teachers make that choice.
interesting, thank you for sharing.
Could I transpose your thought into:
--
Solutions (or large scale programs), should not be written in a general purpose language.
Instead, there should be core domain language (solution DSL) developed (using a general purpose language) and then the solution should be developed using the solution DSL.
?