Recent posts (max 20) - Browse or Archive for more

On the crisis of Go

We should save Go from the current crisis of overconfident narcissistic idiocy.

In the good old times only very few people, who have passed through harsh selection (basically, you have to me Math or EE major) were allowed into PL design. Out of that we got APL, Smalltalk, Common Lisp, Scheme, Miranda, Haskell, Standard ML and Scala - all the nice things.

When demagogues and narcissistic bullshitters were allowed to design a language we got C++, Java with all the inconsistencies and sloppy kitchen sink thinking which are so characteristic of Liberal Arts majors.

When complete degenerates are allowed to design a language, abominations like PHP or Javascript were born.

So, Go has been famous for keeping the list of features small, orthogonal (on the implementation side) and complementary (on the semantic side). It is precisely this what makes it such a success.

It has a multiple return values (not a tuple) similar to Common Lisp and this is the best we could have. Literally.

Introducing the full-blown type-classes (or better to call them type-traits, suggesting that they are composable, or flavors as they used to be named by Symbolics) is a too much effort, basically a design from scratch is required.

Just adding a Maybe monad, as idiots are suggesting, is a bullshit "solution" since it requires type-classes in the first place.

If you are that fucking smart (hint: you are not - thousands of exponentially brighter people have pushed the field since 60s especially in Common Lisp and ML communities) - just fork the language and make it your way, but, please, leave us alone and stop spamming us with your naive bullshit.

Some pastas

some gems from /g/

Ocaml is a product of brain-dead people, like Java. It is really that bad. No proper numeric tower in a functional language is a disaster.

Haskell is a miracle, but it is plagued by idiots and narcissistic degenerates who abuse the type system and Monadic IO by exercising in an idiocy of producing too abstract too general and useless data types where just a function composition and sum-types will do.

So, learn to reduce everything to the smallest possible sets of appropriate idioms.

The current public domain Haskell code form fpcomplete and other narcissistic idiots is utter bullshit. Everything could be done with much more ease and simplicity by merely porting stuff from SML, Erlang (with some message-passing lib) or Common Lisp world. Laziness has been solved by Monadic IO.

Beauty is very very relevant, because it is a sign of approaching perfection (which is a state when there is nothing more left to take away - a local optimum). In nature it is a product of countless trials and errors, while in human crafts it is a product of quality.

Beauty arises out of very good quality, you pleb.

Take a look at the evolution of Haskell's prelude, lets say from ghc-6.x and up to now.

Contrast is which the fucking abomination which is called foundation-0.x which is a product of enterprise degenerates.

and

Your proposition was that code cannot be elegant, beautiful and maintainable at the same time.

I have shown you a concrete example with refutes your idiotic assumption. Just this.

good thread

Tribute

universal_server() ->
    receive
       {become, F} ->
           F()
    end.

factorial_server() ->
    receive
       {From, N} ->
           From ! factorial(N),
           factorial_server()
    end.

factorial(0) -> 1;
factorial(N) -> N * factorial(N-1).

test() ->
    Pid = spawn(fun universal_server/0),
    Pid ! {become, fun factorial_server/0},
    Pid ! {self(), 50},
    receive
        X -> X
    end.

Joe Armstrong is gone

Very sad day. It is a real lose. He was a great wizard, principle-guided.

On the second thought I would say that I always felt happiness and gratitude while reading his books or watching his talks - a lone voice of sanity and principle-guided reason in the sea of screaming bullshit, a lone figure in a crowd of bearded narcissistic clowns, like Wadler or whoever it might be.

This gratitude for showing the power of clear disciplined reasoning guided by the right principles I would carry with me and will try to pass further. Thank you, Joe! You were a great teacher, a guru and you literally have moved the earth!

I think I should have a drink.

Snapd

snapd cannot resume a download after a network error (network change)

fucking degenerates

Oh god

lngnmn1@ideapad:~$ node
> "" == '0'
false
> 0 == ''
true
> 0 == '0'
true
> false == 'false'
false
> false == '0'
true

Wow

This is what we call inconsistent behavior. So much for the principle of less astounishment

lngnmn1@ideapad:~$ python3
Python 3.6.7 (default, Oct 22 2018, 11:32:17) 
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> round(1.5)
2
>>> round(2.5)
2
>>> round(3.5)
4 
>>> round(4.5)
4
>>> round(5.5)
6
>>> round(6.5)
6
>>> 

Fuck off HN

Look, I am really tired of all this. It is very emotionally taxing for nothing. It is not easy to argue in a foreign language about subtle topics. All I have tried to say is that there are language features based on extensive research. Erlang is one example, Go is another. There are obvious counter examples everyone know and love.

My first comment was about that by making an IO selector a language construct the need call Jetty which calls Netty, which call Shitty is eliminated, and the code could be reduced into a single function with a few helpers. This has been demonstrated by Rob Pike in every single fucking video on Youtube.

Creating another general purpose event-driven framework, Tokio or whatever, is, of course, very rewarding, especially for those imposers who call themselves "engineers", but it seems that engineering as a discipline is about reducing to an optimum, instead of piling up fancy bullshit. Every single video of Joe Armstrong on Youtube is about this very difference. We already have way too many Java frameworks.

We could actually compare into which assembly Go's code with select statement compiles versus Rust's code, including dependencies, but it is so obvious that it is almost frustrating to spell this explicitly. That is why I mentioned LOCs.

It is really frustrating to argue when some unknown idiots are flagging your posts without offering any single reason. BTW, if you want to know how shotings are originated - this is this exactly the way. But don't worry, I am very far away in some third world shithole, and I don't care that much.

In good old times, on LKML and everywhere else smart people would focus on meaning and ignore the style, which is one's own choice, while nowadays they attack our style, ignoring the meaning. So be it.

Just fuck this modern HN with all that SJW idiocy.

I really can't stand it, so fuck you, HN.

There is the discussion.

https://news.ycombinator.com/item?id=18636125

The fucking idiots are claiming, that some gut bacteria have been cured autism in a mice!

What the fuck is autism in mice? A cross-species disorder in a species with unrelated structure of the brain? Really?

I am struggling with autism my whole life, and some clowns are getting paid for "modeling" autism on unrelated species? Fuck you! Just fuck you fucking degenerates.

No wonder I have got banned. It is okay to be banned by idiots. There are my post which has been flagged by fucking SJW activists.

What kind of fucking bullshit is this? Autism is a spectrum of compensating behavioral patterns that emerge as the way to diminish unusually high emotional stress (which is also a spectrum) due to genetically transmitted "imbalances" in a brain's structure (and/or biochemistry). So, nowadays every kind of fucking bullshit deserve the label "working hypothesis" instead of "gross incompetence"? BTW, autistic spectrum disorders are "hijacked" the most stable evolutionary strategy of "good looks" - quiet village beauties are carrying these alleles (presumably, product of inbreeding).

There is no coincidence, that ASDs affects mostly boys. Motherly instincts, it seems, diminish (or compensate for) behavioral deviations.

If one could come down to earth from the Ivory towers of abstract bullshit and look at the real world, the answers are out there.

and

How this is related to humans?

What is autism in mice in the first place?

What kind of fucking degenerates are "studying" or "modeling" a cross-species >"mental" disorder???

On species with an almost unrelated brain structure as a "model"?? What kind of >bullshit is this?

and

In not so distant past many of weak-minded but talkative, ambitious and narcissistic people could have find their niche in any organized religion. Almost every fancy bullshit, as long as it fits the canon, could be accepted, praised and even rewarded. There were never a shortage of fancy bullshit. In the current age religions has been obsoleted, but weak-minded "creative" people are still here. So, science became a new religion, especially when it hit the wall of empiricism, a limitation, which has been realized by ancient eastern philosophers (Brahman is unattainable to conditioned intellect which could see nothing, but its conditioning). Modern day's notion of impossibility to break an abstraction barrier (see the wiring of a processor from the level of code) is the very same notion reformulated.

Every bizarre bullshit could be framed as a hypothesis and published, giving a high social status of "theoretical researches" to its authors (instead of much more appropriate status of talkative idiots). It is due to social status, similar to those of a monk in medieval ages, which one's parents could buy for their children by paying them through a costly elite religious school. Nothing new under the moon.

I personally prefer to see those disconnected from reality academics, who gave advice to Macron (based on disconnected from reality abstract notions) to tax the population to combat climate change, to be held accountable for all the damages caused by resulting riots and being forced to pay for their ignorant arrogance, but this will never happen, because academics are allowed to produce bullshit labeled as working hypothesis. The rest of us aren't.

Fundamentally wrong ;)

The very first page shows an utter lack of conceptual discipline (sloopy thinking).

For instance, the following set of commands runs the hello_world example:

git clone https://github.com/SergioBenitez/Rocket
cd Rocket
git checkout v0.4.0-rc.2
cd examples/hello_world
cargo run

Set implies no notion of ordering whatsoever, while a sequence of commands implies a particular definite order.

It is a list of commands, not a set. Don't use fancy words you not fully understand.

https://news.ycombinator.com/item?id=18515678

Epic fight (or fail?)

https://news.ycombinator.com/item?id=18445609

A decent CS degree, like that of MIT matters a lot. I could give an example. Once upon a time a stumbled upon this classic article (which I re-read sometimes to feel better):

https://eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/

When I read this for the first time I have been literally shocked by sudden realization that I have coded some stuff in PHP but never knew it is such a crap.

It also taught me that I literally know nothing, that I am merely a stupid coder, not a programmer, so I undertook a serious study of CS fundamentals to be able to write an article like this in the future.

Now, after a few years of studying, I know a half-a-dozen of languages and I know crap when I see it. Ironically, what is going on with the Node ecosystem puts PHP3 into a shame. But it is natural, because most of JS coders have no CS background. People with CS background sometimes produce gems like Go or Erlang, while "mere coders" always produce things like PHP, J2EE and npm.

There is only one thing that I regret - it could save me so much time by not reading bullshit on the web if only I could find the right books (like Programming Erlang, Haskell School of Expression or On Lisp) and right courses (like Dan Grossman's and 6.001 2004 - the last course in Scheme) first. There is a huge, qualitative difference between a well-written gems like these and fucking crap some narcissistic idiots post in their blogs.

I have found the right books and the right courses by literally swimming through the sewers for years. A decent school will teach you the right principles, instead of irrelevant details, in ML or Scheme right from the beginning.

Cathedral of packer's stupidity.

I managed to stay away from Java crap as much as I could, but I have never suspected that it is really as bad as this. I think crappy design should be a felony like cheats in finances.

I will cite it verbatim as a real piece from the Cathedral of stupidity.

public class ListViewLoader extends ListActivity
        implements LoaderManager.LoaderCallbacks<Cursor> {

    // This is the Adapter being used to display the list's data
    SimpleCursorAdapter mAdapter;

    // These are the Contacts rows that we will retrieve
    static final String[] PROJECTION = new String[] {ContactsContract.Data._ID,
            ContactsContract.Data.DISPLAY_NAME};

    // This is the select criteria
    static final String SELECTION = "((" +
            ContactsContract.Data.DISPLAY_NAME + " NOTNULL) AND (" +
            ContactsContract.Data.DISPLAY_NAME + " != '' ))";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // For the cursor adapter, specify which columns go into which views
        String[] fromColumns = {ContactsContract.Data.DISPLAY_NAME};
        int[] toViews = {android.R.id.text1}; // The TextView in simple_list_item_1

        // Create an empty adapter we will use to display the loaded data.
        // We pass null for the cursor, then update it in onLoadFinished()
        mAdapter = new SimpleCursorAdapter(this,
                android.R.layout.simple_list_item_1, null,
                fromColumns, toViews, 0);
        setListAdapter(mAdapter);

        // Prepare the loader.  Either re-connect with an existing one,
        // or start a new one.
        getLoaderManager().initLoader(0, null, this);
    }

    // Called when a new Loader needs to be created
    public Loader<Cursor> onCreateLoader(int id, Bundle args) {
        // Now create and return a CursorLoader that will take care of
        // creating a Cursor for the data being displayed.
        return new CursorLoader(this, ContactsContract.Data.CONTENT_URI,
                PROJECTION, SELECTION, null, null);
    }

    // Called when a previously created loader has finished loading
    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
        // Swap the new cursor in.  (The framework will take care of closing the
        // old cursor once we return.)
        mAdapter.swapCursor(data);
    }

    // Called when a previously created loader is reset, making the data unavailable
    public void onLoaderReset(Loader<Cursor> loader) {
        // This is called when the last Cursor provided to onLoadFinished()
        // above is about to be closed.  We need to make sure we are no
        // longer using it.
        mAdapter.swapCursor(null);
    }

    @Override
    public void onListItemClick(ListView l, View v, int position, long id) {
        // Do something when a list item is clicked
    }
}

https://developer.android.com/guide/topics/ui/layout/listview.html

Bitcoin $1,500

Time to say something on the occasion.

There is no way to get out of this keeping such inflated valuation. No institution would buy bitcoin in case of a selloff, which will happen some day or another.

Another notion is that there is just not enough free USD to convert any substantial amount of BTC, an operation which by itself will trigger a selloff and burst.

These millionaires are only on a disk. There is no way to cash it out on such valuation.

It is a trap. The classic case of inflated asset bubble, given that asset is virtual and the Ponzi scheme is global.

Lets see.

Gold Standard

Peter Norvig's code is a gold standard.

http://nbviewer.jupyter.org/url/norvig.com/ipython/Probability.ipynb

Habitual clarity, precise use of language and attention to details.

This is what programming is all about.

Notice also how expressive and concise Python3 is.

Perfectly sums up what is PHP

This is the quote from https://phacility.com/phabricator/

  • Written in PHP so literally anyone can contribute, even if they have no idea how to program.

This is a precise description of what PHP is.

The sad truth

Programming is mostly about what are you doing and why instead of how and with what tools.

Data structures and related algorithms is central to programming, not languages. A programming language should be programmable (to be adapted, evolved into a set of layered DSLs for a problem domain), like Common Lisp.

Programming languages is an easy part...

3rd account has been banned on HN

A have reached yet another milestone - my 3rd account has been banned on HN. That is something.

Is it a hint that I am a complete idiot or something is wrong with the "social media" world? Both, perhaps. Something is definitely wrong with the world in which Java and Javascript are the most popular languages and statistics is used instead of experimentally proven causality.

But there is no other choice but to continue to do what you like, the way you like.. Everything else is even more meaningless.

Oops, I monad again

This boils down to an ugly hack which is what a monad is.

The principle is that a function by definition is a mapping, which maps a set of values into another set of values. The crucial difference between a function and a procedures is that a function must, by definition, produce the same input for the same output. Always.

So, when a supposed function produces sometimes values and sometimes errors, everything is broken. It is not a function anymore. The ugly hack is to wrap different values into a compound structure of a certain type and reformulate the law of functions to the law of procedures - the same type of output for same values. This is what Maybe monad and Either monad are. Mere ADTs, mere wrappers. As long as input and output values are of the same type (as long as they conform to the same protocol/interface they are considered to be equivalent, but, of course, not equal) procedures which take such type as input and output values could be composed and form a pipelines (like any other procedures with consistent types).

There is nothing more than that. And, strictly speaking, it is not a pure functional programming anymore. Just procedural with static typing (hello, Haskell purists!).

'Breakthrough' Prizes

While multidimensional geometry could be regarded as a separate discipline, dimensions themselves does not exist. It is mere an abstraction created by an observer.

A sphere makes a perfect sense in a in this Universe, while a 4D hyper-sphere (and so-called hyper-cube) is an utter nonsense. Of course, one could describe such an abstraction in as a mathematical object, but it will be mere an abstraction, like Hegelian ones. It does not exist outside people's heads.

All the billions years of this planet never revealed a single dimension. All the geometry we have in proteins is based on the notion of 3D spheres - a notion of the same distance in all possible dimensions (given that there is no such thing as dimension).

Same logic could be applied to refute any string theory sectarian nonsense, given that just one single contradiction is enough. Non-existence of time as a phenomena is enough to destroy all the space-time curvature mathematical or rather Hegelian crap.

But who cares.