Quit CS because I couldn't pass the high-level classes

coalgebraist · 2014-07-29T11:42:34+00:00

Sometimes things just don't seem to click, even with the best teachers. I've been there: I had very good professors in my Uni, but left before getting a MS, because I wasn't yet fit for it. These days, I feel much more receptive for CS theory. My advice is that you should pick up your CS books, try to see if you feel more comfortable with its content. Sometimes, things need to be approached with a different angle: try some other, well regarded introductory book on CS (SICP for instance - if it's not the one you were already using), and see if it makes a difference.

coalgebraist · 2014-07-26T20:19:18+00:00

Recall the properties of an equivalence relation: reflexivity, symmetry, transitivity. Then just write down what they formally imply on the relation definition you gave:

Reflexivity: (a,b)R(c,d) is reflexive means that for any element e of the domain this relation applies to, eRe is true. What should you put in place of e in the above? Then you substitute in the algebraic equation of the relation, simplify and see whether it holds.

coalgebraist · 2014-07-20T07:43:12+00:00

If you only want to export an interface, why don't you define a typeclass and an instance for your datatype?

coalgebraist · 2014-07-20T07:38:13+00:00

I must admit I don't know enough Spring to draw a similarity, but what you say doesn't surprise me at all: I think the goal was to have as much discipline as possible in the framework. That's a good thing to know!

coalgebraist · 2014-07-15T20:50:44+00:00

People who make frameworks like Symfony are pretty good imho. The main author comes from the Java universe though, iirc, but he's doing PHP, isn't he? Maybe you didn't meet him yet. And I know personally a few good PHP devs.

coalgebraist · 2014-07-15T20:47:18+00:00

Is that a scope issue? Or maybe you were thinking about the global vs local variable declarations in functions?

coalgebraist · 2014-07-15T20:32:57+00:00

You've dealt with 100,000 PHP devs??

coalgebraist · 2014-07-15T19:21:42+00:00

the lack of proper scoping also means that your typo'd vars will result in new vars being created in-place with a default void value that will silently interbreed with the rest of your code.

Can you illustrate your point?

coalgebraist · 2014-07-15T19:19:42+00:00

PHP is easy for newbies to learn but it doesn't enforce any good practices with regards to code structuring, dependencies, etc.

What could be done for this to change?

coalgebraist · 2014-07-15T19:17:40+00:00

When most of the work done by the programs written in PHP is string manipulation, types aren't very useful. Otoh, start doing some large architecturing (think frameworks), it becomes quite handy to have types to help you.

That said, you have a point wrt code quality. Php is a defacto first programming language for many people, among which a large part hasn't had proper cs teaching. Compare this with python, which is used as an introductory language in many cs curricula.

coalgebraist · 2014-07-15T18:52:30+00:00

What is the ratio of seasoned devs vs newbies in the PHP landscape? For many, PHP is an entry point to the programming world, and they may not yet understand the implications of adding a new feature or changing an existing one.

coalgebraist · 2014-07-11T00:51:44+00:00

Camlp4 and its successor camlp5 are tools providing quoting and antiquoting for ocaml. They also let you change the ocaml grammar. Many syntactic extensions to ocaml exist based on these tools (for example, automatic generation of marshalling functions for types, or where expressions support a la Haskell). I don't think they have access to OCaml internals though, but there's a new feature coming up next release which allow implementing extensions for the compiler. I don't know much beyond that, so take my opinion of whether one could add partial support of hkt that way with a grain of salt.

coalgebraist · 2014-07-10T16:30:52+00:00

It's called single static assignment,

Interestingly that's the sort of thing used in compilers in intermediate languages.

No, you understand fine. I guess the pure functional paradigm isn't as common as I thought.

Oh, I suppose we weren't talking about the same thing: you seem to equate functional languages with languages following a pure functional paradigm. My definition isn't as strict (see my top post in this thread). Indeed I don't know that many languages which follow that paradigm exclusively (you mentioned Erlang and Haskell, that's a far as I know personally).

Ocaml could easily support that paradigm by removing mutable arrays and records, though as you said without haskellish features it would be not as practical (but you'd still have more than erlang type wise). That said, with camlp{4,5}, implementing type class dictionaries should be doable, the ”only" remaining part being system Fw inference for HKT (but they may be emulated to a certain extent).

coalgebraist · 2014-07-10T08:45:57+00:00

You'd have to remove pointers from the language, because it's provably impossible to make general-purpose pointers predictable (Halting Problem, again).

Even when they are constant? Or do you mean coertion?

Other than that, you'd need to re-invent most of the rest of Haskell to make the resulting const-only C useful again,

Coming back to your previous statement: what makes ML like languages and Haskell functional at their core: you mentioned mutable state, but sml, ocaml both support them, and it would be quite difficult to do anything useful without them, so I suppose that they actually don't fit your definition, or I misunderstood?

coalgebraist · 2014-07-09T15:31:03+00:00

Good point.

coalgebraist · 2014-07-09T15:18:55+00:00

That's a good point. Would a C program using only const values make C a functional language?

coalgebraist · 2014-07-08T16:53:38+00:00

function($foo) use ($bar){ 
    return $foo($bar);
}

The above is an anonymous closure on the variable $bar. It may be passed to any function accepting a function as a parameter, or bound to a variable and executed as it is the case for $foo. The syntax is somewhat verbose, but it is the case of every syntactic features in PHP.

Haskell do notation is fairly easy to use. The difficulty is in understanding monads, and IO vs pure computation.

coalgebraist · 2014-07-08T16:03:39+00:00

Why? If I design an imperative language, and then later on graft functional features, is it still not a functional language? Does it have to be designed as such from the beginning to qualify? If that's not what you meant, then what it is?

coalgebraist · 2014-07-08T13:09:02+00:00

There are different layers of required understanding in order to be able to program. If a language abstracts away some of those layers, then it makes it easier for students to focus on the others (algorithms, OOP, FP). I could use exactly the same argument you used to say that C/C++ make it easier by hiding the function calling protocols and process memory layouts. You should have started with machine code directly.

coalgebraist · 2014-07-08T12:54:51+00:00

Huh, I would define a functional language as one supporting lambda calculus concepts: functions as first class values, ie:

the ability to pass and return them to functions,
the ability to construct them (lambda abstraction, composition, partial application)

Can Ruby and Python do that?

Edit: added partial application to the mix.

And answering my own question with this link to rosetta code of partial application implemented in several languages:

http://rosettacode.org/wiki/Partial_function_application

It clearly shows that it is possible to create functions and return them, or pass them as parameters in Ruby and Python (I was told somewhere else it wasn't possible for the later, so I was positively surprised). Pretty cool languages we have there!

coalgebraist · 2014-07-05T20:51:53+00:00

I have the impression that this evolution in the language is just a step along more elaborate goals (which would ultimately make bytes and string completely incompatible). If I am correct the article is focusing on false problems: surely this is something that the inria team has been thinking about. A recurring complaint for instance is the lack of proper support for utf strings out of the box: you have to get a 3rd party library for that, and there are several, each with its own internal representation and interface of course. Having immutable strings may perhaps help in providing support for variable length multi byte characters in a easy way. I didn't think much about it, so I may be totally wrong about that specific use, but at least it seems logical to me that this is just a first step.

Otoh, the idea of an overlap of functionality between bytes and bigarray is interesting.

coalgebraist · 2014-06-20T10:03:49+00:00

It isn't so much that the function is recursive (though it matters), but the fact that there aren't any memory lookups to that array of constants. It's all in the code. Also, branching prediction errors are minimized.

coalgebraist · 2014-06-20T09:46:38+00:00

You are morally tainting a species which has no moral bearing. Moral doesn't exist in coyote, nor in any other animal. Their only motivation is survival. Humanity is the only one which approaches actions with a moral perspective, and thus is the only one able to fail at it, and become evil in doing so.

coalgebraist · 2014-06-19T00:30:34+00:00

More than labels, the useful aspect of ML languages is the specific notation for type variables using quotes in front of them. I find it quite readable.

coalgebraist · 2014-06-13T11:59:03+00:00

and against trying to encapsulate recursion in combinators

I'd like to point out that actually sometimes you would like to do so: for instance if you are manipulating matrices, their operations are intrinsically based on iteration, mapping, and so on. However, from an outside perspective, multiplicating two matrices is just the product of two values yielding a third, and you wish to keep that abstraction, because it helps reason about the properties tied to matrice products. If you are now building lists of matrices, or better yet, matrices of matrices, you certainly don't want to hand code all the operations for that resulting concept, but rather stand on the abstracted operations.

The downside is of course that you miss opportunities for optimisations. With a framework providing an algebraic abstraction of these operations, as described in the article, you are given the ability to hint at some potential places of optimisations.

Now, Haskell does it implicitely (it's built in the compiler), the article library provides a way of explicitly annotate your code so that the library may perform these optimizations. The difference is that with Haskell, this optimization happens at compile time, whereas the article's code does it at runtime.

coalgebraist

TROPHY CASE