Haskell – 56 – inizio – 4

Continuo da qui, copio qui.

Sequenze
Miran titola “Texas ranges”; Miran rockz! 👽

What if we want a list of all numbers between 1 and 20? Sure, we could just type them all out but obviously that’s not a solution for gentlemen who demand excellence from their programming languages. Instead, we’ll use ranges. Ranges are a way of making lists that are arithmetic sequences of elements that can be enumerated. Numbers can be enumerated. One, two, three, four, etc. Characters can also be enumerated. The alphabet is an enumeration of characters from A to Z. Names can’t be enumerated. What comes after “John”? I don’t know.

To make a list containing all the natural numbers from 1 to 20, you just write [1..20]. That is the equivalent of writing [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20] and there’s no difference between writing one or the other except that writing out long enumeration sequences manually is stupid.

Prelude> [1..20]
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
Prelude> ['a'..'z']
"abcdefghijklmnopqrstuvwxyz"
Prelude> ['K'..'Z']
"KLMNOPQRSTUVWXYZ"

Ranges are cool because you can also specify a step. What if we want all even numbers between 1 and 20? Or every third number between 1 and 20?

Prelude> [2,4..20]
[2,4,6,8,10,12,14,16,18,20]
Prelude> [3,6..20]
[3,6,9,12,15,18]

It’s simply a matter of separating the first two elements with a comma and then specifying what the upper limit is. While pretty smart, ranges with steps aren’t as smart as some people expect them to be. You can’t do [1,2,4,8,16..100] and expect to get all the powers of 2. Firstly because you can only specify one step. And secondly because some sequences that aren’t arithmetic are ambiguous if given only by a few of their first terms.

To make a list with all the numbers from 20 to 1, you can’t just do [20..1], you have to do [20,19..1].

Watch out when using floating point numbers in ranges! Because they are not completely precise (by definition), their use in ranges can yield some pretty funky results.

Prelude> [0.1, 0.3 .. 1]
[0.1,0.3,0.5,0.7,0.8999999999999999,1.0999999999999999]

My advice is not to use them in list ranges.

You can also use ranges to make infinite lists by just not specifying an upper limit. Later we’ll go into more detail on infinite lists. For now, let’s examine how you would get the first 24 multiples of 13. Sure, you could do [13,26..24*13]. But there’s a better way: take 24 [13,26..]. Because Haskell is lazy, it won’t try to evaluate the infinite list immediately because it would never finish. It’ll wait to see what you want to get out of that infinite lists. And here it sees you just want the first 24 elements and it gladly obliges.

A handful of functions that produce infinite lists:

cycle takes a list and cycles it into an infinite list. If you just try to display the result, it will go on forever so you have to slice it off somewhere.

Prelude> take 10 (cycle [1,2,3])
[1,2,3,1,2,3,1,2,3,1]
Prelude> take 12 (cycle "LOL ")
"LOL LOL LOL "

repeat takes an element and produces an infinite list of just that element. It’s like cycling a list with only one element.

Prelude> take 10 (repeat 5)
[5,5,5,5,5,5,5,5,5,5]

Although it’s simpler to just use the replicate function if you want some number of the same element in a list.

Prelude> replicate 3 10
[10,10,10]

🤩

Annunci

Haskell – 55 – inizio – 3

Continuo da qui, copio qui.

Introduzione alle liste
Much like shopping lists in the real world, lists in Haskell are very useful. It’s the most used data structure and it can be used in a multitude of different ways to model and solve a whole bunch of problems. Lists are so awesome. In this section we’ll look at the basics of lists, strings (which are lists) and list comprehensions.

In Haskell, lists are a homogenous data structure. It stores several elements of the same type. That means that we can have a list of integers or a list of characters but we can’t have a list that has a few integers and then a few characters. And now, a list!

Note: We can use the let keyword to define a name right in GHCI. Doing let a = 1 inside GHCI is the equivalent of writing a = 1 in a script and then loading it. Non sono sicuro che sia necessario, difatti provo a ometterlo.

Prelude> lostNumbers = [4,8,15,16,23,42]
Prelude> lostNumbers
[4,8,15,16,23,42]

As you can see, lists are denoted by square brackets and the values in the lists are separated by commas. If we tried a list like [1,2,'a',3,'b','c',4], Haskell would complain that characters (which are, by the way, denoted as a character between single quotes) are not numbers. Speaking of characters, strings are just lists of characters. "hello" is just syntactic sugar for ['h','e','l','l','o']. Because strings are lists, we can use list functions on them, which is really handy.

A common task is putting two lists together. This is done by using the ++ operator.

Prelude> [1,2,3,4] ++ [9,10,11,12]
[1,2,3,4,9,10,11,12]
Prelude> "hello" ++ " " ++ "world"
"hello world"
Prelude> ['w','o'] ++ ['o','t']
"woot"

Watch out when repeatedly using the ++ operator on long strings. When you put together two lists (even if you append a singleton list to a list, for instance: [1,2,3] ++ [4]), internally, Haskell has to walk through the whole list on the left side of ++. That’s not a problem when dealing with lists that aren’t too big. But putting something at the end of a list that’s fifty million entries long is going to take a while. However, putting something at the beginning of a list using the : operator (also called the cons operator) is instantaneous.

Prelude> 'A':" SMALL CAT"
"A SMALL CAT"
Prelude> 0:[1,2,3,4,5]
[0,1,2,3,4,5]

Notice how : takes a number and a list of numbers or a character and a list of characters, whereas ++ takes two lists. Even if you’re adding an element to the end of a list with ++, you have to surround it with square brackets so it becomes a list.

[1,2,3] is actually just syntactic sugar for 1:2:3:[]. [] is an empty list. If we prepend 3 to it, it becomes [3]. If we prepend 2 to that, it becomes [2,3], and so on.

Note: [], [[]] and [[],[],[]] are all different things. The first one is an empty list, the seconds one is a list that contains one empty list, the third one is a list that contains three empty lists.

If you want to get an element out of a list by index, use !!. The indices start at 0.

Prelude> "Steve Buscemi" !! 6
'B'
Prelude> [9.4,33.2,96.2,11.2,23.25] !! 1
33.2

But if you try to get the sixth element from a list that only has four elements, you’ll get an error so be careful!

Lists can also contain lists. They can also contain lists that contain lists that contain lists …

Prelude> b = [[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
Prelude> b
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
Prelude> b ++ [[1,1,1,1]]
[[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3],[1,1,1,1]]
Prelude> [6,6,6]:b
[[6,6,6],[1,2,3,4],[5,3,3,3],[1,2,2,3,4],[1,2,3]]
Prelude> b !! 2
[1,2,2,3,4]

The lists within a list can be of different lengths but they can’t be of different types. Just like you can’t have a list that has some characters and some numbers, you can’t have a list that has some lists of characters and some lists of numbers.

Lists can be compared if the stuff they contain can be compared. When using <, <=, > and >= to compare lists, they are compared in lexicographical order. First the heads are compared. If they are equal then the second elements are compared, etc.

Prelude> [3,2,1] > [2,1,0]
True
Prelude> [3,2,1] > [2,10,100]
True
Prelude> [3,4,2] > [3,4]
True
Prelude> [3,4,2] > [2,4]
True
Prelude> [3,4,2] == [3,4,2]
True

What else can you do with lists? Here are some basic functions that operate on lists.

head takes a list and returns its head. The head of a list is basically its first element.

Prelude> head [5,4,3,2,1]
5

tail takes a list and returns its tail. In other words, it chops off a list’s head.

Prelude> tail [5,4,3,2,1]
[4,3,2,1]

last takes a list and returns its last element.

Prelude> last [5,4,3,2,1]
1

init takes a list and returns everything except its last element.

Prelude> init [5,4,3,2,1]
[5,4,3,2]

If we think of a list as a monster, here’s what’s what.

But what happens if we try to get the head of an empty list?

Prelude> head []
*** Exception: Prelude.head: empty list

Oh my! It all blows up in our face! If there’s no monster, it doesn’t have a head. When using head, tail, last and init, be careful not to use them on empty lists. This error cannot be caught at compile time so it’s always good practice to take precautions against accidentally telling Haskell to give you some elements from an empty list.

length takes a list and returns its length, obviously.

Prelude> length [5,4,3,2,1]
5

null checks if a list is empty. If it is, it returns True, otherwise it returns False. Use this function instead of xs == [] (if you have a list called xs)

Prelude> null [1,2,3]
False
Prelude> null []
True

reverse reverses a list.

Prelude> reverse [5,4,3,2,1]
[1,2,3,4,5]

take takes number and a list. It extracts that many elements from the beginning of the list.

Prelude> take 3 [5,4,3,2,1]
[5,4,3]
Prelude> take 1 [3,9,3]
[3]
Prelude> take 5 [1,2]
[1,2]
Prelude> take 0 [6,6,6]
[]

See how if we try to take more elements than there are in the list, it just returns the list. If we try to take 0 elements, we get an empty list.

drop works in a similar way, only it drops the number of elements from the beginning of a list.

Prelude> drop 3 [8,4,2,1,5,6]
[1,5,6]
Prelude> drop 0 [1,2,3,4]
[1,2,3,4]
Prelude> drop 100 [1,2,3,4]
[]

maximum takes a list of stuff that can be put in some kind of order and returns the biggest element.
minimum returns the smallest.

Prelude> minimum [8,4,2,1,5,6]
1
Prelude> maximum [1,9,2,3,4]
9

sum takes a list of numbers and returns their sum.
product takes a list of numbers and returns their product.

Prelude> sum [5,2,1,6,3,2,5,7]
31
Prelude> product [6,2,1,2]
24
Prelude> product [1,2,5,6,7,9,2,0]
0

elem takes a thing and a list of things and tells us if that thing is an element of the list. It’s usually called as an infix function because it’s easier to read that way.

Prelude> 4 `elem` [3,4,5,6]
True
Prelude> 10 `elem` [3,4,5,6]
False

ovviamente si può fare à la lisp

Prelude> elem 4 [3,4,5,6]
True
Prelude> elem 10 [3,4,5,6]
False

Those were a few basic functions that operate on lists. We’ll take a look at more list functions later.

🤩

cit. & loll – 73

Buona festa a quelli che per loro è festa, per tutti ecco qua 😋

A code smell is a surface indication
::: RichRogersIoT

For the technologist change is always slower than they expect
::: amasad

Once you get to a certain level of experience
::: CodeWisdom

Fastest way to compute a result
::: SusanPotter

phew glad my rabbit didn’t login as root
::: bcrypt

LC_COLLATE
::: ExaGridDba ::: Stack Exchange

sign in a doctor waiting room
::: glipari ::: Phastidio

me, programming c++: i’m afraid to compile this because everything will break me
::: arshia__

Vorrei far notare che molti dei siti di #FakeNews del M5S e Lega, gestiti da #MarcoMignona, nella notte sono magicamente spariti
::: tomtweet3

LOL | Fake news, stretta del governo sulle comari di paese
::: Mantzarlis

I love 2017
su Zuck, da leggere tutte le repliche/commenti
::: Bmac0507

Good engineering involves thinking about if things can be made to work
::: manisha72617183

The most underrated part of open source
::: thejameskyle

Tasso di disoccupazione del Giappone, il paese più robotizzato al mondo
::: MinutemanItaly

Functional Programming: look after beginners, the experts will look after themselves
::: leighmgibson

Don’t waste toner
::: _youhadonejob1

Once I have a good feel about the goals, then the real programming begins
::: CodeWisdom

I’ve found that almost all programming is surprisingly similar
::: CodeWisdom

The most underrated part of open source
::: thejameskyle

$ 1.000 sulla borsa USA 10 anni fa, quanto valgono ora?
::: setteBIT

Comparing to another activity is useful if it helps you formulate questions
::: CodeWisdom

Ma il primo utente Twitter cosa faceva?
::: BastaLucy

Okay, where should I start?
::: BDuszel

Current development speed
::: RichRogersIoT

Automatic Semicolon Insertion (ASI) is a syntactic error correction procedure
::: mathias

List of things unpopular with programmers that I enjoy and have produced valuable solutions with
::: preaction

FP is just programming with functions
bellissimissima 💥💥💥
::: jdegoes

Why #Golang was designed to suck
::: StephenPiment

I’ve seen things you people wouldn’t believe
::: irwin

It’s amazing how important kinaesthetic learning is in programming
::: _wilfredh

Know ahead of time that change is hard, so you are not getting discouraged
::: YouthKiAwaaz

Data is NOT the new oil. Education is
::: marcelsalathe

In a functional program, you know what f(x) means by blindly substituting x into the inlined body of f
::: jdegoes

This is how and why I started my blog back in 2012
l’inizio di una grande impresa
::: jakevdp

Being a good, senior dev is easy
::: RichRogersIoT

If you can’t explain it simply
::: RichRogersIoT

Isaac Asimov – I, Robot
::: fannVEVO

Mathematics is an experimental science, and computing is the experiment
::: Jose_A_Alonso

If I succeed I will call the tool ripripgrep
::: keleshev

When you really, really miss pizza… you CASUALLY mention it to the International @Space_Station
::: astro_paolo

The three most dangerous things in the world
::: CodeWisdom

Most future predictions are bound by future technologies
::: amasad

I know I’m more of a programmer than a mathematician
::: wallingf

I disagree – quiet NaN propagation is horrible – I think you should generate an exception immediately instead of creating a NaN
::: joeerl

My tweets/followers/following were all permutations of 243
smetti e blocca tutto; no basta lo screenshot
::: TaurineAndCode

Nothing that a bit of superglue can’t fix 🙂
::: joeerl

Reusability is key in reducing bugs and coding quickly
::: CodeWisdom

There are two ways of constructing a software design
::: CodeWisdom

Funniest geek short ever
::: dcavedon

Apple’s week in software
::: tomwarren ::: JonyIveParody

Conceptual simplicity does not always mean shorter code
uh! add1 c’è anche in Racket, non lo sapevo
::: _wilfredh

#Linux from scratch, in real life
::: 0xUID

I can’t wait to see the day this happens with functional languages
::: felixbr_

Lisp is a language for doing
::: azzamoky

dang, I’m so impressed that I saw this thread and didn’t even need to put on my Racket evangelist hat because plenty of other people had already donned it for me
ok, non è per tutti; dai non te la prendere 😯
::: lexi_lambda

Imperative programming is an overly academic topic
::: puffnfresh

Remember when Structured Programming was the latest airy, impractical academic fad to be judiciously avoided by Real Programmers
::: Symbo1ics

Even the humble subroutine was a hard sell back then
::: Symbo1ics

Making mistakes is human
::: nixcraft

Sometimes it pays to stay in bed on Monday
::: CodeWisdom

Much of the essence of building a program
::: CodeWisdom

Y a combien d’autres candidats ?
::: CommitStrip

WHAT’S THAT FREAK DOING IN THE TRAIN
::: lukaseder ::: TimmGut

#haskell is my not so secret, secret sauce
::: raichoo

C with no mitigations is the safest language to write code in, what a fascinating take
::: pcwalton

Twitter is the app I use when
::: max_read

Crypto currencies are the worst nightmare for the oligarchy
::: KimDotcom

Mi fa ben sperare…
::: madbob

A #Google devono cambiare spacciatori
::: sdallagata

Computer Science is a science of abstraction
::: CodeWisdom

The Programmers’ Credo
::: RichRogersIoT

junior dev: “i found the bug”
::: fioroco

Dear news organizations of the internet: never the fuck ever do I want to watch a video instead of read the article I clicked on. I don’t care if it’s related to the article or not
😁 😁 😁
::: seldo

I am leaving Twitter. I can’t take all the political banter and the mean and nasty things people say on here anymore
::: mattZillaaaa

CryptoKitties
::: jbrukh

Most JS/Python/Ruby apps…
::: reubenbond

TFW you look for the instructions to perform a task you only do every ~6 months
::: doughellmann

And remember: no evidence whatsoever!
::: fabiochiusi

10 reasons to teach coding and participate in the #HourofCode
::: MIT_CSAIL

I find programming a fascinating area
::: CodeWisdom

The average user doesn’t give a damn what happens
::: CodeWisdom

The history of programming languages is basically a chronicle of our attempts to turn FORTRAN into a LISP
::: gvwilson

We managers get a little more obsolete every day
::: RichRogersIoT

mai, MAI, tentare con la versione in italiano di un sito
::: hronir

Happy 60th Birthday (Dec 4th) to Eric S. Raymond
::: climagic

Leggere e scrivere dizionari (e JSON)

Forse ne ho già parlato in passato (ma la memoria…) e non è nemmeno una cosa tanto interessante ma capita e allora ecco 😊

Il dictionary è un tipo che può tornare comodo, spesso. Ci sono diversi modi per creane; copio dalla documentazione:

a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})
a == b == c == d == e
True

Spesso nella pratica succede che la costruzione avviene più gradualmente:

d0.py

dic = {}

dic.update({1:'foo'})
k = 3
v = 'baz'
dic.update({k:v})
k = 'due'
v = 'bar'
dic.update({k:v})

print('dic =', dic)      #1

dic.update({5:'cinque'})
print('dic =', dic)      #2

dic.pop(5)               #3
print('dic =', dic)

Autoevidente ma comunque lo creo vuoto, lo popolo e visaulizzo (#1). Aggiungo un altro elemento (#2), che poi cancello (#3).

Questo è semplice, sarebbe possibile crearlo ogni volta, probabilmente con uno o più cicli leggendo i dati da file.

Ma se il dizionario, costruito in tempi successivi, supera una certa dimensione conviene scriverlo su file e poi rileggerlo quando serve.

Anticamente (non so se c’è anche su questo blog) usavo istruzioni molto semplici.
Per memorizzarlo su file:

d1.py

dic = {1: 'foo', 3: 'baz', 'due': 'bar'} #1
st = str(dic)                            #2
with open('dic', 'w') as f:
    f.write(st)

il dizionario dic in #1 è quello precedentemente costruito. Per scriverlo su file devo conventirlo in stringa (#2).

Successivamente posso leggerlo:

d2.py

with open('dic', 'r') as f:
    st = f.read()            #1

dic = eval(st)               #2
print(dic)
print(type(dic))             #3

lo leggo come stringa (#1) che valuto con eval() (#2) ottenendo quanto voluto (#3).

OK, funziona. Ma si può fare in modo più canonico (Python è un linguaggio ancora in evoluzione, nel senso che si aggiungono moduli a un ritmo sconvolgente).

d3.py

import json                  #1

with open('jdic', 'r') as f: #2
    try:
        dic = json.load(f)
    except ValueError:
        dic = {}

print(dic)

Sì, esiste il modulo json (#1) che fa quello che ci serve. Con un paio di avvertenze:

  • sia le chiavi che i valori devono essere stringhe;
  • occorre usare " come delimitatore di stringa; ' da errore.

Questo è il contenuto del file jdic

La scrittura su file del dizionario via json peraltro non è soggetta alle condizioni necessarie per la lettura; la conversione a stringa di chiavi e valori che si rendessero necessarie è trasparente:

d4.py

import json

dic = {1: 'foo', 3: 'baz', 'due': 'bar'} #1

with open('jdicw', 'w') as f: #2
    json.dump(dic, f)

Il formato JSON è molto popolare, Python si adegua, esiste json.tool che deve essere usato nel terminale:

🤩

Haskell – 54 – inizio – 2

Continuo da qui, copio qui.

Siamo sempre ai ripassi, ecco le prime funzioni 😋

In the previous section we got a basic feel for calling functions. Now let’s try making our own! Open up your favorite text editor and punch in this function that takes a number and multiplies it by two.

Prelude> doubleMe x = x + x
Prelude> doubleMe 21
42

Ma attenzione: il prof  stressa  di fare le cose per bene –concordo 😁

Functions are defined in a similar way that they are called. The function name is followed by parameters seperated by spaces. But when defining functions, there’s a = and after that we define what the function does. Save this as baby.hs or something. Now navigate to where it’s saved and run ghci from there. Once inside GHCI, do :l baby. Now that our script is loaded, we can play with the function that we defined.

Prelude> :l baby
[1 of 1] Compiling Main             ( baby.hs, interpreted )
Ok, modules loaded: Main.
*Main> doubleMe 10
20
*Main> doubleMe 2.7818
5.5636

Because + works on integers as well as on floating-point numbers (anything that can be considered a number, really), our function also works on any number. Let’s make a function that takes two numbers and multiplies each by two and then adds them together.

doubleUs x y = x*2 + y*2

Simple. We could have also defined it as doubleUs x y = x + x + y + y. Testing it out produces pretty predictable results (remember to append this function to the baby.hs file, save it and then do :l baby inside GHCI).

*Main> :l baby
[1 of 1] Compiling Main             ( baby.hs, interpreted )
Ok, modules loaded: Main.
*Main> doubleUs 4 9
26
*Main> doubleUs 2.3 34.2
73.0
*Main> doubleUs 28 88 + doubleMe 123
478

As expected, you can call your own functions from other functions that you made. With that in mind, we could redefine doubleUs like this:

doubleUs x y = doubleMe x + doubleMe y

This is a very simple example of a common pattern you will see throughout Haskell. Making basic functions that are obviously correct and then combining them into more complex functions. This way you also avoid repetition. What if some mathematicians figured out that 2 is actually 3 and you had to change your program? You could just redefine doubleMe to be x + x + x and since doubleUs calls doubleMe, it would automatically work in this strange new world where 2 is 3.

Functions in Haskell don’t have to be in any particular order, so it doesn’t matter if you define doubleMe first and then doubleUs or if you do it the other way around.

Now we’re going to make a function that multiplies a number by 2 but only if that number is smaller than or equal to 100 because numbers bigger than 100 are big enough as it is!

doubleSmallNumber x = if x > 100
                        then x
                        else x*2

Right here we introduced Haskell’s if statement. You’re probably familiar with if statements from other languages. The difference between Haskell’s if statement and if statements in imperative languages is that the else part is mandatory in Haskell. [Ricorda qualcuno? Sì ma zitto!]. In imperative languages you can just skip a couple of steps if the condition isn’t satisfied but in Haskell every expression and function must return something. We could have also written that if statement in one line but I find this way more readable. Another thing about the if statement in Haskell is that it is an expression. An expression is basically a piece of code that returns a value. 5 is an expression because it returns 5, 4 + 8 is an expression, x + y is an expression because it returns the sum of x and y. Because the else is mandatory, an if statement will always return something and that’s why it’s an expression. If we wanted to add one to every number that’s produced in our previous function, we could have written its body like this.

doubleSmallNumber' x = (if x > 100 then x else x*2) + 1

Had we omitted the parentheses, it would have added one only if x wasn’t greater than 100. Note the ' at the end of the function name. That apostrophe doesn’t have any special meaning in Haskell’s syntax. It’s a valid character to use in a function name. We usually use ' to either denote a strict version of a function (one that isn’t lazy) or a slightly modified version of a function or a variable. Because ' is a valid character in functions, we can make a function like this.

conanO'Brien = "It's a-me, Conan O'Brien!"

There are two noteworthy things here. The first is that in the function name we didn’t capitalize Conan’s name. That’s because functions can’t begin with uppercase letters. We’ll see why a bit later. The second thing is that this function doesn’t take any parameters. When a function doesn’t take any parameters, we usually say it’s a definition (or a name). Because we can’t change what names (and functions) mean once we’ve defined them, conanO'Brien and the string "It's a-me, Conan O'Brien!" can be used interchangeably.

OK, è solo un ripasso –ma fatto molto bene. Adesso pausa 😋

🤩

TIL anche questo

If you are the smartest person in the room, then you are in the wrong room.
Confucius

E sì! 🐳 Certo. E quelli di reddit, dove la cit. ha un’altra attribuzione, al solito la sanno lunga e disquisiscono, qui.

Se con una piccola astrazione consideriamo il Web come un ambiente (cioè con case) e un social come una di queste e chi seguo su Twitter come una stanza risulta –per quanto mi riguarda– confermata la saggezza di Confucio e Richard.

Sì perché –oggettivamente– seguo nerds che davvero rockzs! 💥 👽
Anzi se avessi tempo potrei seguirne tanti altri.

Alle volte qualcuno esagera, come oggi. Ho provato a resistere, pensare alle funzioni nella programmazione funzionale, ma niente da fare: devo dirvelo, se del caso non leggete.

Ci sono cose che avrei potuto inventare io se non ci fosse qualcuno che mi ha preceduto, vedi Peano, l’HTML, cioè il Web, per dirne un paio. Altre invece sono meno auto-evidenti, non ci sarei mai arrivato, la Relatività Generale, ma anche quella ristretta, o la saga di Diskworld, per dire.

Ecco un caso di quest’ultima classe, qui.

Partiamo dall’immagine, di autore ignoto anche se meriterebbe fama imperitura. Riesce a visualizzare un concetto che è –come dire…– forse non solo per me. E la sua applicazione! Io che sono vecchio ricordo certe discussioni Google vs. Yahoo dove c’era chi citava [autocensura qui] e –OK, discordi da piola dietro un fiasco di barbera.

Tornando al tweet poi, certo, di lì si parte seguendo il link proposto e si viene condotti alla scoperta di tutto un mondo da nerds mooolto più smart di me.

OK, è tutto quello che volevo dire. E il Web e Twitter come parte dello stesso rockzs! 💥 👽

Forse è solo per me, forse no, chissà. Ah! posso smettere quando voglio, nèh! Forse 😋

🤩

Haskell – 53 – inizio – 1

Continuo da qui, copio qui.

Ready, set, go!
Alright, let’s get started! Miran raccomanda qualche raccomandazione e dice che si userà ghci; OK. Ah! cambia il prompt: The prompt here is Prelude> but because it can get longer when you load stuff into the session, we’re going to use ghci>. If you want to have the same prompt, just type in :set prompt "ghci> ".

* hs-53 $ ghci
GHCi, version 8.0.2: http://www.haskell.org/ghc/  :? for help
Prelude> :set prompt "ghci> "
ghci> 5 * 8 + 2
42
ghci>

Segue con cose  tranquille  note; p.es. non funziona 5 * -3 ma si deve scrivere 5 * (-3).

Boolean algebra is also pretty straightforward. As you probably know, && means a boolean and, || means a boolean or. not negates a True or a False.

OK, e poi… What about doing 5 + "llama" or 5 == True? Well, if we try the first snippet, we get a big scary error message!

ghci> 5 + "llama"

:3:1: error:
    • No instance for (Num [Char]) arising from a use of ‘+’
    • In the expression: 5 + "llama"
      In an equation for ‘it’: it = 5 + "llama"
ghci> 5 == True

:4:1: error:
    • No instance for (Num Bool) arising from the literal ‘5’
    • In the first argument of ‘(==)’, namely ‘5’
      In the expression: 5 == True
      In an equation for ‘it’: it = 5 == True
ghci>

OK, cose note. You can’t compare apples and oranges. We’ll take a closer look at types a bit later. Note: you can do 5 + 4.0 because 5 is sneaky and can act like an integer or a floating-point number. 4.0 can’t act like an integer, so 5 is the one that has to adapt.

ghci> 5 + 4.0
9.0
ghci>

You may not have known it but we’ve been using functions now all along. For instance, * is a function that takes two numbers and multiplies them. As you’ve seen, we call it by sandwiching it between them. This is what we call an infix function. Most functions that aren’t used with numbers are prefix functions. Let’s take a look at them.

ghci> succ 7
8

The succ function takes anything that has a defined successor and returns that successor. As you can see, we just separate the function name from the parameter with a space. Calling a function with several parameters is also simple. The functions min and max take two things that can be put in an order (like numbers!). min returns the one that’s lesser and max returns the one that’s greater. See for yourself:

ghci> min 9 10
9
ghci> min 3.4 1.2
1.2
ghci> max 100 101
101

However, if we wanted to get the successor of the product of numbers 9 and 10, we couldn’t write succ 9 * 10 because that would get the successor of 9, which would then be multiplied by 10. So 100. We’d have to write succ (9 * 10) to get 91.

ghci> succ (9 * 10)
91

If a function takes two parameters, we can also call it as an infix function by surrounding it with backticks. For instance, the div function takes two integers and does integral division between them. Doing div 92 10 results in a 9. But when we call it like that, there may be some confusion as to which number is doing the division and which one is being divided. So we can call it as an infix function by doing 92 `div` 10 and suddenly it’s much clearer.

ghci> div 92 10
9
ghci> 92 `div` 10
9

Lots of people who come from imperative languages tend to stick to the notion that parentheses should denote function application. For example, in C, you use parentheses to call functions like foo(), bar(1) or baz(3, "haha"). Like we said, spaces are used for function application in Haskell. So those functions in Haskell would be foo, bar 1 and baz 3 "haha". So if you see something like bar (bar 3), it doesn’t mean that bar is called with bar and 3 as parameters. It means that we first call the function bar with 3 as the parameter to get some number and then we call bar again with that number. In C, that would be something like bar(bar(3)).

OK, cose note ma riparto per bene, con un ripasso 😋

🤩

Haskell – 52 – riparto con un nuovo tutorial

Ricomincio con Haskell –o almeno ci provo come dicevo qui— un nuovo tutorial.

Ce ne sono millemila online, anzi sul sito di Haskell c’è una ricca lista di documenti, perché non cominciare dal primo? Anche perché è consigliato in diversi altri luoghi. E allora via con Learn You a Haskell for Great Good! di Miran Lipovača.

Miran è un po’ misterioso, questo dovrebbe essere lui. Non l’ho trovato sui social, chissà. Ah, prima che mi dimentico:

Il tutorial non è recente (aprile 2011) ma non dovrebbe essere un problema (sempre della serie “mi dicono”). E poi parte bene, quasi come la H2G2: Hey yo! This is Learn You a Haskell, the funkiest way to learn Haskell, which is the best functional programming language around. You may have heard of it. This guide is meant for people who have programmed already, but have yet to try functional programming. The whole thing is completely free to read online, but it’s also available in print and I encourage you to buy as many copies as you can afford.

OK, parto, qui.

Introduzione
Miran è anche un illustratore, bravo, e io adoro le immagini quando pertinenti e OK, ecco.

This tutorial is aimed at people who have experience in imperative programming languages (C, C++, Java, Python …) but haven’t programmed in a functional language before (Haskell, ML, OCaml …).

I failed to learn Haskell approximately 2 times [uh! 😯] before finally grasping it because it all just seemed too weird to me and I didn’t get it. But then once it just “clicked” and after getting over that initial hurdle, it was pretty much smooth sailing. I guess what I’m trying to say is: Haskell is great and if you’re interested in programming you should really learn it even if it seems weird at first. Learning Haskell is much like learning to program for the first time — it’s fun! It forces you to think differently, which brings us to the next section …

Ma cos’è Haskell?
Haskell is a purely functional programming language. OK, salto questa della differenza tra i linguaggi imperativi e quelli funzionali l’ho già sentita, saprei anche ripeterla, casomai la difficoltà è applicarla.

So in purely functional languages, a function has no side-effects. The only thing a function can do is calculate something and return it as a result. At first, this seems kind of limiting but it actually has some very nice consequences: if a function is called twice with the same parameters, it’s guaranteed to return the same result. That’s called referential transparency and not only does it allow the compiler to reason about the program’s behavior, but it also allows you to easily deduce (and even prove) that a function is correct and then build more complex functions by gluing simple functions together.

Haskell is lazy. Anche qui salto, ma è importante, se del caso Miran lo spiega bene.

Haskell is statically typed. Non come altri linguaggi anche molto di moda, sapete a chi mi riferisco.

Haskell is elegant and concise. Because it uses a lot of high level concepts, Haskell programs are usually shorter than their imperative equivalents. And shorter programs are easier to maintain than longer ones and have less bugs.

Haskell was made by some really smart guys (with PhDs). Work on Haskell began in 1987 when a committee of researchers got together to design a kick-ass language. In 2003 the Haskell Report was published, which defines a stable version of the language. Ehi! se i nerds lo usano devo poterlo fare anch’io, nèh! 😋

Cosa serve per partire
A text editor and a Haskell compiler. Li ho. For the purposes of this tutorial we’ll be using GHC, the most widely used Haskell compiler. Anche questo. So hanche della possibilità di compilare ma della praticità della versione interattiva, la REPL ghci: The usual workflow for me when playing around in stuff is defining some functions in a .hs file, loading it up and messing around with them and then changing the .hs file, loading it up again and so on. This is also what we’ll be doing here. Uh, anch’io. Insomma pronto a (ri)partire 😁

🤩

Difficoltà con la programmazione funzionale

Recentemente ho iniziato a sbirciare roba riguardante la programmazione funzionale, Haskell in particolare. Con grosse difficoltà, provo a scriverle così forse riesco anche a chiarirmi.

Comincio con due giustificazioni in parte auto-assolutorie.

Per prima cosa vengo da una lunga storia in cui ho cambiato diverse volte tutto (o quasi). Non avete idea di come si faceva ai miei tempi con il Fortran; certi costrutti erano molto simili all’assembler (OK, molto semplificato ma tutti quei GOTO e gli IF calcolati). E te lo insegnavano così anche a scuola, peccato non aver conservato gli appunti. Poi –come già detto– c’è stata una lunga evoluzione… A proposito tendo a auto-censurarmi anche su Turbo Pascal > Borland Pascal > Delphi; forse perché solo Windows, forse perché la gente (quelli che conosco) preferiva il Basic (anche qui tutta una lunga serie di sapori).

C’è poi un altro motivo: sono vecchio. E con l’età –posso citare un über-nerd? ecco:

Non ci sono dubbi, c’è una ragione per cui si va a scuola da giovani: il cervello e la sua plasticità invecchiano, e, sebbene sia possibile tenerli allenati, come per tutti gli allenamenti la fatica e lo sforzo aumentano con il tempo.

Qui, al punto 3. Notare che Marco è molto più giovane di me, per dire io ho avuto contatti professionali con il suocero (sì rockz anche lui).

C’è infine un altro motivo, quasi altrettanto importante: if it ain’t broke, don’t fix it (qui).

Che nel mio caso implica che non si deve cambiare niente visto che Python | Matlab (Octave) | Visual Basic | you name it va benissimo. Sì con Windows. Non vi dico della mia proposta di dare una chance a Julia 😐

Ma chissene! mica lo faccio più per lavoro, per un ritorno pratico! ormai sono fuori e posso dedicarmi a quello che mi piace. Per esempio il Lisp (in realtà un’evoluzione, Racket, che è Scheme) l’ho tenuto in stand-by per 30 anni 👽

E adesso –per quel che ne so, sono isolato in fondo alla West Padagna– sono sexy Go, Rust e Haskell.

Sono partito a seguire un tutorial che non mi ha soddisfatto più di tanto; mi ha lasciato con idee confuse. E poi non è nemmeno finito. Ma non mi arrendo, anzi presto comincio con un altro, diverso.

Intanto ho scoperto questo post: A Beginner-Friendly Tour through Functional Programming in Scala. Parla di Scala ma vale per l’FP tutta. Un po’ lungo (e forse troppo dettagliato) ma OK. Ecco:

The essential core of functional programming is quite simple: build programs by composing functions.

In this context, “function” does not refer to a “computer science” function, that is, a hunk of machine code, but rather, a mathematical function:

Totality. A function must yield a value for every possible input.

Determinism. A function must yield the same value for the same input.

Purity. A function’s only effect must be the computation of its return value.

OK, tutto da leggere; non l’ho stampato, anche se… (sono vecchio).

Poi, prossimamente… forse… probabilmente… 😊

🤩

Visto nel Web – 316

Post troppo lungo e non organizzato ma 1) Nete Neutrality in pericolo; 2) #cazzari locali contro le fake news come le vedono loro; 3) malanni di stagione vari & ventuali. Ma ecco cosa ho wisto nel Web.

Leghisti e grillini, ecco i siti e le pagine Facebook imparentate
#:politica
::: la Stampa ::: Andst7 ::: fabiochiusi ::: _arianna

Bloomberg Op-Ed: The Internet ‘Already Lost Its Neutrality’
#:Web, Internet
::: Slashdot

I often tell students that linked list implementations are surprisingly varied and can be tricky to get right
#:algoritmi, codice
::: johnregehr

Artificial intelligence can be held to human-like standards of accountability
#:artificial intelligence
::: Floridi

Is Elon Musk Greatly Exaggerating Tesla’s Battery Technology?
#:innovazioni, futuro
::: Slashdot

Most of the smartest thinkers I know are working in the cryptocurrency space
#:sicurezza, spionaggio, virus
::: jmj

I believe @fedora is going in the right direction with @ProjectAtomic workstation
#:sistemi operativi
::: evacchi

Dedicato a chi continua a dubitare che l’Italia della ricerca continua a far bene nonostante risorse ridicole
#:artificial intelligence
::: demartin

The 6 Laws of Technology Everyone Should Know
#:innovazioni, futuro
::: mims

There’s A Cluster of 750 Raspberry Pi’s at Los Alamos National Lab
#:hardware
::: Slashdot

Uscita la rivista Full Circle Magazine #127 #Ubuntu
#:programming, codice, snippet
::: sdallagata

Fakenews-washing
#:fake news, bufale
::: evgenymorozov

Microsoft issued me a Mac when they hired me to help people use Linux on Azure
#:sistemi operativi
::: bridgetkromhout

Large C# & VB solutions load tons faster in the 15.5 update to #VS2017
#:linguaggi di programmazione
::: _geniodelmale

Linux Release Roundup: gThumb, Peek Gif Recorder + More
#:tools, componenti software
::: lucaciavatta

Computer Pioneer Geoff Tootill Passed Away
#:protagonisti #:storia
::: Slashdot

Bad news from Mashable, BuzzFeed, and Vice shows times are rough for ad-supported digital media
#:Web, Internet
::: RadioProzac

“The dominant philosophy in Silicon Valley is a form of determinism that sees technology as an unstoppable force” toward Singularity
#:innovazioni, futuro
::: FrankPasquale

Why is Facebook so useful to the junta?
#:social media
::: ThereIsNoMagic

Did Elon Musk Create Bitcoin?
mah… 😯
#:protagonisti
::: Slashdot

UNIX V5, OpenBSD, Plan 9, FreeBSD, and GNU coreutils implementations of echo.c
#:linguaggi di programmazione #:storia
::: AlecMuffett

Apple’s Secure Enclave Processor (SEP) Firmware Decrypted
#:sicurezza, spionaggio, virus
::: kwestin

Ugo Mattei: perché non ti fanno più togliere la batteria dallo smartphone (e molto altro)
#:sicurezza, spionaggio, virus
::: Yi_Benevolence

AI/robotics are technologies, and are different from food/drugs/… which are industries. We need new regulations for food/drugs/planes/cars/media/finance/education given AI advances. But let’s use industry-specific risks as the starting point for regulating that industry
#:artificial intelligence #:innovazioni, futuro
::: AndrewYNg

Digital archivists: NEVER substitute text when OCR’ing technical material. Indeed, never substitute at all
#:dati, raccolta
::: Symbo1ics

Clear Linux Beats CentOS, openSUSE, and Ubuntu in (Enterprise) Benchmark Tests
#:sistemi operativi
::: Slashdot

How to tweet from Racket
#:lisp(s)
::: lambda_calculus

An open and accessible internet for all is one of the core beliefs behind our software
#:Web, Internet
::: torproject

The End of the Social Era Can’t Come Soon Enough
#:social media
::: Donearm

Exference: Haskell tool to generate expressions from types
José posta cose per nerd estremi e io sono ancora aspirante niubbo 😐
#:programmazione funzionale
::: Jose_A_Alonso ::: Jose_A_Alonso

Death of a closed-source enterprise software salesman
#:free open source software
::: lucaciavatta ::: lucaciavatta

Getting started with reinforcement learning
#:artificial intelligence
::: lucaciavatta

Ricordiamo che questo astuto è lo stesso renziano che ha fatto ridere il mondo per essersi fatto sgamare (Renzi dixit) in questa maniera buffa
#:fake news, bufale
::: mazzettam

Il problema del CEO senza visione
#:ditte
::: iannak1

Russia’s Security Council plans to introduce mandatory identification of online gamers & social media users via phone numbers
#:sicurezza, spionaggio, virus
::: tanyalokot

un privato (Facebook) può sequestrare o comunque censurare un giornale regolarmente registrato senza che questo abbia commesso nessun illecito, e senza alcun motivo apparente
#:Web, Internet #:censura
::: fabiochiusi

In tema di #FakeNews, torna d’attualità la lucida riflessione di @CBlengio
#:fake news, bufale
::: nexacenter ::: CBlengio

La soluzione per combattere la disinformazione, spiega Carrai, sono algoritmi che ci dicano cosa è vero e cosa è falso
#:fake news, bufale
::: PietroSalvatori ::: fabiochiusi ::: fabiochiusi ::: fabiochiusi

Tip: in IPython terminal or Jupyter notebook, run %notebook -e history.ipynb
#:tip, suggerimenti
::: pydatasci

Tim Wu: Why the Courts Will Have to Save Net Neutrality
#:Web, Internet
::: Slashdot

e ma bisogna avvertirli, nel DDL contro le fake news ci hanno messo un sacco di reati, ma si sono dimenticati le fake news 🤔
#:politica
::: brunosaetta ::: guidoscorza

Intervista a Community – Rai Italia – su nanoelettronica con materiali 2D
si può essere chiari e comprensibili restando corretti; chissà se Fabio Fazio, Carlo Conte e Paolo Fox?
#:innovazioni, futuro
::: Iannaccone

Tumblr Is Tumbling
#:social media
::: Slashdot

EU lawmakers back exports control on spying technology
#:sicurezza, spionaggio, virus
::: fabiochiusi

L’affascinante novità fake news nel panorama del dibattito pubblico fa sì che abbia rilasciato a maggio l’intervista che potrei rilasciare oggi, sul tema
#:fake news, bufale
::: fabiochiusi

The FCC is giving major corporations even more control over the media, paving the way for megamergers like Sinclair-Tribune. We have to fight for less consolidation to save our democracy
#:Web, Internet
::: RoKhanna

Comcast Hints At Plan For Paid Fast Lanes After Net Neutrality Repeal
#:Web, Internet
::: Slashdot

Carp: A statically typed Lisp, without a GC, for high performance applications
#:lisp(s)
::: Jose_A_Alonso

Facciamo un patto di correttezza in vista delle elezioni. Guai a utilizzare fake news e bufale
ma ti puoi fidare di quel #cazzaro? io no 😡
#:fake news, bufale #:politica
::: fabiochiusi

@nyuniversity just opened a research institute dedicated to studying the social implications of artificial intelligence
#:artificial intelligence
::: NPRWeekend

White House Weighs Personal Mobile Phone Ban For Staff
#:dispositivi mobili
::: Slashdot

Pokemon Go Led To Increase In Traffic Deaths and Accidents
#:games
::: Slashdot

La rete di disinformazione, NYT, BuzzFeed, Renzi, la propaganda e il caos informativo
#:fake news, bufale
::: _arianna

Why Python and Pygame are a great pair for beginning programmers
#:tip, suggerimenti
::: lucaciavatta

Our mission is to increase the number of Common lispers in the world
#:lisp(s)
::: xach

Ma di che sta parlando? Secondo ogni ricerca e rilevamento il social network più infettato dall’odio, più incline ad aizzare linciaggi e più gonfio di ingiurie e minacce è Facebook, dove gli odiatori ci mettono nome, cognome, faccia, dati sensibili e cazzi propri
#:social media
::: Wu_Ming_Foundt

Numerical computation in native Haskell
#:programmazione funzionale
::: Jose_A_Alonso

Legittima difesa
filtri su Facebook
#:tools, componenti software
::: Siamo Geek

Good article on #privacy safeguards
#:sicurezza, spionaggio, virus
::: EasyCrypt_co

SalentOS Neriton 2.0 is ready for release! Dopo un gran bel po di lavoro il team di sviluppo è lieto di annunciare che “Nerìton”
#:sistemi operativi
::: BlogSalentos

HP Quietly Installs System-Slowing Spyware On Its PCs, Users Say
#:sicurezza, spionaggio, virus
::: Slashdot

Android ti spia: sa dove sei anche col GPS spento, e registra audio e video a tua insaputa
#:sicurezza, spionaggio, virus
::: dcavedon

Google Can Tell if Someone Is Looking at Your Phone Over Your Shoulder
#:sicurezza, spionaggio, virus
::: Slashdot

Microsoft Sees the Future of Windows 10 as Sets, Ditching Windows For a Tabbed App Interface
non m’interessa, non uso queste ——skif cose 😋
#:sistemi operativi
::: Slashdot

New NSA Leak Exposes Red Disk, the Army’s Failed Intelligence System
#:sicurezza, spionaggio, virus
::: Slashdot

FCC Chairman Ajit Pai Criticizes Companies That Oppose His Efforts To Repeal Net Neutrality Rules
#:Web, Internet
::: Slashdot

Il fenomeno delle fakenews spiegato in un tweet
#:fake news, bufale
::: Il_Vitruviano

If we’re going to replace JavaScript
#:linguaggi di programmazione
::: jevakallio

this one covering basic usage of syntax-local-value
#:lisp(s)
::: lexi_lambda

MacOS High Sierra Bug Allows Login As Root With No Password
#:sistemi operativi
::: Slashdot

9 Truths Computer Programmers Know
#:programming, codice, snippet
::: RichRogersIoT

My explainer on where we are with FCC Chairman Pai’s proposal to eliminate #netneutrality
#:Web, Internet
mah… fortemente contrario 😡
::: vanschewick

A Supreme Court Case This Week Could Change US Digital Privacy Standards
#:sicurezza, spionaggio, virus
::: Slashdot

My Future of Pandas slides from NYC PyData 2017
#:linguaggi di programmazione
::: jreback

The FCC’s decision to gut net neutrality protections isn’t just partisan business as usual; it’s a withdrawal from over a decade of work to protect Internet users from unfair practices by ISPs
#:Web, Internet
::: EFF

Computer algorithms were trained by @drfeifei and her team to recognize the make, model and year of every car in more than 50 million Google Street View images
#:artificial intelligence
::: Stanford

Break Up Google and Facebook If You Ever Want Innovation Again
#:innovazioni, futuro
::: Slashdot

AI Goes Bilingual — Without a Dictionary
#:artificial intelligence
::: Slashdot

Yes, Emacs does “violate” the Unix philosophy—and that’s a good thing
Emacs difatti richiede tempo per imparare a usarlo e apprezzarlo
#:tools, componenti software
::: tikhonjelvis

From 0 to Kubernetes
#:tools, componenti software
::: lucaciavatta

10 open source technology trends for 2018
#:programming, codice, snippet
::: lucaciavatta

Graph theory and Geogebra
#:linguaggi di programmazione
::: spectrumgomas

Remember this bug next time the FBI & DOJ ask for “reasonable” encryption
#:sicurezza, spionaggio, virus
::: Snowden ::: Ptidel

Samsung Develops ‘Graphene Ball’ Battery With 5x Faster Charging Speed
#:innovazioni, futuro
::: Slashdot

This is the regime’s media project. And it is working
#:fake news, bufale
::: jayrosen_nyu

The California Review of Images and Mark Zuckerberg is out today! Six amazing essays on the visual culture of Zuck
#:protagonisti
::: timhwang

AWS launches bare metal instances
#:hardware
::: nicolaiarocci

Meet the man who deactivated Trump’s Twitter account
#:social media
::: CaseyNewton

European Union regulations on algorithmic decision-making and a “right to explanation”
#:artificial intelligence
::: Jose_A_Alonso

Search DuckDuckGo from the Command Line
#:Web, Internet
::: lucaciavatta

Worried about online tracking? Find out how vulnerable you really are with Panopticlick
::: chris_dag

Apple To Review Software Practices After Patching Serious Mac Bug
#:sicurezza, spionaggio, virus
::: Slashdot

This is how #NetNeutrality works
woz rockz 💥
#:Web, Internet
::: GoogleFacts

I’ve been a bit ambivalent about Python type-hinting, but after seeing @joelgrus’s mypy workflow I’m ready to try it out
#:programming, codice, snippet
::: jakevdp

Deciphering Haskell’s applicative and monadic parsers
#:programmazione funzionale
::: Eli Bendersky

As leak investigations surge, our new lawsuit—in partnership with @knightcolumbia—seeks the Trump admin’s guidelines on surveillance of journalists
#:censura
::: FreedomofPress

VERIFICARE
After playing a little bit with QBasic when I was a kid, I was given a K&R C book
#:programming, codice, snippet
::: wycats

Facebook’s New Captcha Test: ‘Upload A Clear Photo of Your Face’
#:ditte
::: Slashdot

Bravo @EPICprivacy: “Algorithmic transparency must be a fundamental principle for consumer protection”
#:algoritmi, codice
::: FrankPasquale

Windows 10 Now on 600 Million Active Devices
#:sistemi operativi
::: slashdot

Post-mortem of the macOS root authentication bug, explaining why it happened
#:sicurezza, spionaggio, virus
::: kaepora

What is ReasonML?
#:programmazione funzionale
::: 2ality

Microsoft: We’re Razing Our Redmond Campus To Build a Mini City
#:ditte
::: Slashdot

Snapchat Is Becoming the Anti-Facebook
#:social media
::: Slashdot

That’s a wrap! Now we wait to find out if justices agree the Fourth Amendment also protects our digital data
#:Web, Internet
::: ACLU

Physicists Made An Unprecedented 53 Qubit Quantum Simulator
#:innovazioni, futuro
::: Slashdot

Interactive Workflows for C++ with Jupyter
Uh’nteressante 😜
#:linguaggi di programmazione
::: ProjectJupyter

Primacy or Recency? Non leggiamo (quasi) più, scannerizziamo
#:Web, Internet
::: SergioGridelli

La fine degli #antivirus
#:sicurezza, spionaggio, virus
::: formicablu

We are excited to release 0x Connect! 🚢 Write programs that seamlessly pull liquidity and trade with any 0x relayer
#:programming, codice, snippet #:Web, Internet
::: 0xProject

mal – Make a Lisp, guile version
über l’idea di mal; avendo tempo / chissà 🐳
#:linguaggi di programmazione
::: spectrumgomas

Questa non è una fake news ma è di uno squallore immenso
#:fake news, bufale
::: _arianna

Global press freedom plunges to worst level this century
#:censura
::: fabiochiusi

Bitcoin’s boosters argue that the currency is valuable because its supply is limited to 21m
#:Web, Internet
::: TheEconomist

+80 organisations representing broad spectrum of stakeholders join forces to warn Member States & EU Institutions that the discussion around the #Copyright Directive are on the verge of causing irreparable damage
#:copyright e brevetti
::: _C4C_

Learn Go through Web Development it would use @gobuffalo_io to learn Go, exploring core concepts as you need them
devo ancora vederlo ma sembra sexy
#:linguaggi di programmazione
::: bphogan

Rust is awesome and desperately needs to exist
lunga discussione, interessante imho
#:linguaggi di programmazione
::: keleshev

Elon Musk’s Boring Company Bids On Chicago Airport Transit Link
#:innovazioni, futuro
::: Slashdot

System76 Will Disable Intel Management Engine On Its Linux Laptops
#:sistemi operativi
::: Slashdot

This is very welcome tooling for #Haskell including refactorings like rename, organise imports/extensions, extract/inline bindings
#:programmazione funzionale
::: steshaw

my “so you want to be a wizard” zine is now available for free!
#:manuali, how to
::: b0rk

Dal 12 dicembre #agcom potrà fare sanzioni da 2,5 mln di euro per violazioni roaming e neutralità della rete, grazie emendamento @ivancatalanodep a legge europea 2017
#:Web, Internet
::: AlessLongo

Paying it forward at Finland’s Aalto Fablab
#:innovazioni, futuro
::: lucaciavatta

Must read for everyone, not just in Silicon Valley
#:sicurezza, spionaggio, virus
::: marcelsalathe

Easier to read than write!
#:programming, codice, snippet
::: _wilfredh

“Linux From Scratch (LFS)” Updated version 8..1
#:manuali, how to
::: b3h3m0th

Some websites use a simple technique to keep their cryptocurrency mining JavaScript under the radar and secretly running in the background, even when the users close the web browser
#:sicurezza, spionaggio, virus
::: manisha72617183

Pyramid Scheme is implemented using the appropriately-named Racket
uh! ‘n altro; sembra tremendamente accattivante 👽
#:lisp(s)
::: wallingf ::: jackrusher

Linux Journal Ceases Publication
#:media
::: Slashdot

Europe Needs to Save Itself From Internet Upload Filters
#:copyright e brevetti
::: OpenMediaOrg

But, what the heck is Linux?
#:sistemi operativi
::: lucaferrari15

Twitter basically just admitted it doesn’t understand its own policies
#:social media
::: MashableAlerts

Homeland Security Claims DJI Drones Are Spying For China
#:sicurezza, spionaggio, virus
::: Slashdot

The AI Index is out!
#:artificial intelligence
::: AndrewYNg

Volunteers Around the World Build Surveillance-Free Cellular Network Called ‘Sopranica’
#:dispositivi mobili
::: Slashdot

Controversial Study Claims ‘Smartphone Addiction’ Alters the Brain
è il metodo Beppe per cuocere le uova; coreanu copyoni! 😋
#:dispositivi mobili
::: Slashdot

Ecco i colossi web che collaborano di più con le autorità
#:Web, Internet
::: fabiochiusi

In China, Great Firewall reinforcer Lu Wei leaves behind a sterile but profitable internet landscape
#:Web, Internet
::: WSJ

GM Says It Will Put Fleets of Self-Driving Cars In Cities In 2019
#:innovazioni, futuro
::: Slashdot

Shouting ‘Pay Your Taxes’, Activists Occupy Apple Stores in France
#:ditte
::: Slashdot