The Big Programming Thread - Page 907

On September 22 2017 12:54 NovemberstOrm wrote:
Anyone familiar with Moment JS? And knows how to parse dates/time pulled from an API(json format) into only hours/minutes?

moment("123", "hmm").format("HH:mm") === "01:23"
moment("1234", "hmm").format("HH:mm") === "12:34"

On September 22 2017 15:55 Manit0u wrote:


https://momentjs.com/docs/#/parsing/string-format/

At the bottom of the section:

moment("123", "hmm").format("HH:mm") === "01:23"
moment("1234", "hmm").format("HH:mm") === "12:34"

On September 21 2017 08:56 Manit0u wrote:
Guys, I need a bit of help with conceptual work. Maybe some of you have had any experience with something like that before...

Basically it's all about process pipelining. We create the configuration and then each process step (step in the pipeline) receives some input files and produces some output files. The problem I'm facing at the moment is that different processes require different file and I need to map the correlations.

Example:

Process A has input files a, b, c and produces output files d, e.
Process B has input files f, g and produces output file h.

All the inputs/outputs need to be unique (it matters which one is which, don't ask me why) so when I go to the next step in the pipeline (process A finished) I need to know that I have to pass output d as input g and output e as input f so that process B can start.

I can't discover/calculate this on the fly since process configuration might change but all of the old jobs (series of steps) have to retain their old configuration.

Now. What do you think would be the best way to map such configurations in the database (postgres) so that it isn't too clunky to retrieve/parse?

The only thing I came up with this far is some form of config table, which will be attached to the process (one process has many configs and each config specifies the relation between output of this process and input of the next one) but this seems super fragile...

CREATE TABLE Processes (
  id INT NOT NULL,
  name VARCHAR[64] NOT NULL,
  CONSTRAINT pk_processes PRIMARY KEY (id));

CREATE TABLE Files (
  id INT NOT NULL,
  name VARCHAR[64] NOT NULL,
  producer INT,
  consumer INT,
  CONSTRAINT pk_files PRIMARY KEY (id),
  CONSTRAINT fk_files__producer__processes__id FOREIGN KEY (producer) REFERENCES Processes(id),
  CONSTRAINT fk_files__consumer__processes_id FOREIGN KEY (consumer) REFERENCES Processes(id));

CREATE TABLE File_consumers (
  id INT NOT NULL,
  file INT NOT NULL,
  consumer INT NOT NULL,
  CONSTRAINT pk_file_consumers PRIMARY KEY(id),
  CONSTRAINT fk_file_consumers__file__files__id FOREIGN KEY (file) REFERENCES Files(id),
  CONSTRAINT fk_file_consumers__consumer__processes_id FOREIGN KEY (consumer) REFERENCES Processes(id));

On September 25 2017 03:35 travis wrote:
I have to write an ocaml function that takes 2 lists and returns a list of tuples, where each tuple is a pair of elements - 1 from each list

for example [1. 2. 3] [5,6] would return [(1,5);(1.6),(2,5);(2.6),(3,5);(3.6)]

Here's the kicker. We're supposed to be able to do it without using recursion, and without using helper methods other than fold methods, map method, append method (combine 2 lists), and length method (length of list)


function signature is:

let pairs lst1 lst2 =



I solved it by doing:

let rec pairs lst1 lst2 = match lst1 with
		[] -> []
	|	h::t -> append (fold_right (fun x a -> (h, x)::a) lst2 []) (pairs t lst2)

And it says I will get full points for that. But I am supposed to be able to solve this without recusion and I want to know how.



IMPORTANT EDIT:

Apparently ocaml doesn't treat this function as recursive. I can get rid of the "rec" in my function signature and everything works fine. Why is this not considered recursive? Is it because it's tail recursive?

let pairs l1 l 2 = List.map (fun x -> List.map (fun y -> (x, y)) l2) l1 |> List.flatten

On September 24 2017 14:38 Thaniri wrote:
Anyone play with golang as a scripting language?

I've begun an internship this month and my task is to work with a team of 3 people to redesign and rebuild the way the company does builds and deployments of their application. Right now the build/deploy system works but is a hard to maintain behemoth of bash scripts that kick off other bash scripts being called by teamcity and jenkins. At least it's version controlled.

I want to pitch to my team the idea of using golang for rewriting all of these infrastructure scripts. Basically because it is strongly and statically typed I believe that it is a more maintainable scripting language compared to bash or python.

Points of resistance: no-one else seems to know golang, and I'm a fucking interrn.

On September 25 2017 03:41 Liebig wrote:


This is a recursive function, i imagine you are testing in a REPL, try restarting from scratch and remove the rec, it should reject it

As for a solution, i think this should work

let pairs l1 l 2 = List.map (fun x -> List.map (fun y -> (x, y)) l2) l1 |> List.flatten

On September 25 2017 04:05 travis wrote:


ah you're right, that must be it. I am using a repl

as for your solution, I am not allowed to use the list module. only pervasives, and the functions I listed (fold_left, fold_right, map, append, length). But I suppose that flatten is basically the append we have given to use.


And so I am trying to understand what you are doing
So this maps each l1 element x to each l2 element y in the form (x, y)

It will work like that? really cool, I'll check it out

|> is like a unix pipe? So that won't work for me here unfortunately. How can I use append for each list that is made by the outside List.map ?

I suppose I could do a fold on the list of lists and do an append for each list to combine them ?


edit: got it working. no recursion. very cool, thank you.

On September 25 2017 03:48 Poirier255 wrote:


It depends.

Did you completely inherit this legacy code or are you working with folks who know this stuff and have years of experience working with the system?

If it's completely yours; and you're confident enough that you can rewrite all of this already set-in-stone, tested, tried-and-true set of scripts, then do it. You have all the power, just remember to use it wisely.

However if you're an intern in an age-old company that just knows how its stuff roles on a day to day basis, anything you screw up is going to cause panic, and nobody will like you for that. Don't rewrite something for the sake of complexity unless you work with it on a daily basis and feel that a rewrite would GREATLY (serious emphasis on this word) improve your productivity. Otherwise, it's there, and it works; don't change it for the sake of complexity (it's really not that bad, as much as you might want to believe it is).

I don't know how critical your system is, but typically you don't want to fix something that isn't broken; especially if you're just trying to look good to your managers so you can have that job at the end of your internship.

Don't look at a company using old technology as an "Omg they need to catch up!" type of deal. A company is there to make money. If the system that's in place is bringing in the dough, you want to be very careful when you're tasked with tampering with that system.

On September 25 2017 06:02 Thaniri wrote:


The way builds are done at the company is a recognized problem. The amount of fixing is what is up for debate. Some say complete rewrite, some say refactor. The debate will hopefully be settled soon. The team lead wants golang, junior wants python, original guys want to stay on bash or MAYBE go to ruby. As an intern, my opinion won't really matter all that much I don't think but, given that it is potentially quite a large project, I think that golang is a good option.

For instance I'm going to demo a script I built in golang that updates all of our alerts to ping the correct domains after a blue/green deployment. Currently that is a manual process, and my script can potentially make it a one click or even completely automated process. I could have written it in bash just as well but just wanted to see how golang works.

On September 25 2017 08:09 Thaniri wrote:
To prevent the risk of misspeaking about our situation, I'll accept that I shouldn't push golang just cause I think it's cool.

To explain why we need to change our build system as simply as possible: there are different deployment procedures for different environments and that's a pain in the ass. We want to consolidate it into a single common procedure for every environment.

Orchestration is no problem for now, we use Puppet for system configurations. Ansible has been pitched as well. When I say deployment I mean simply the software releases that go out to every environment. Not tearing down and rebuilding the VMs running the software.

On September 25 2017 04:26 Liebig wrote:


Yes I'm basically building a list [(x,y1);(x,y2),...] for each x in l1 and y1, y2,... in l2
So you get a list of lists, and the result you want is the one where you "flatten" the list.

|> is defined as let (|>) x f = f x. So this is basically syntactic sugar to say take everything before |> and give it as argument to the function that is after.

I think flatten can be defined as fun x -> fold_right append x []

On September 25 2017 20:20 Acrofales wrote:


Looks right to me. It's a restricted version of flatten, but it's perfect in this case. I can't comment on syntax, but my knowledge of foldr.

If you can't use syntactic sugar for chaining together functions just write it in order. It's uglier and far harder to understand, but there's no functionality lost.

If all the code above is valid ocaml, I have to say it looks very similar to Haskell. I'll have to look into what the actual differences are between the two, because the core functional programming looks almost identical (with a slightly different syntax). Does ocaml have monads?

E: Google answered. Yes, ocaml has monads. Insofar as I can see, the type system is the main difference, and some of the plumbing.
https://www.quora.com/Which-of-Haskell-and-OCaml-is-more-practical-For-example-in-which-aspect-will-each-play-a-key-role

On September 25 2017 22:17 Liebig wrote:

One big difference between Haskell and OCaml is that one is call by name, while the other is call by value.

{{ selectedElement[selectedProperty] }}

On September 27 2017 11:41 Piledriver wrote:
Anyone familiar with AngularJS? Could you help debug this plunk?

plnkr.co

Basically I have an array of objects, and the user can select any object on the array, and then a particular property on the array to see its value.

This binding syntax has usually worked for me, but I'm not able to make it work for any reason today.

  <body ng-controller="MainCtrl">
    Array Element:
    <select ng-model="selectedIndex">
      <option ng-repeat="obj in testData.Table1" value="{{obj.Index}}">{{obj.Index}}</option>
    </select>
    <br>
    <br>
    Property Name:
    <select ng-model="selectedProp">
      <option ng-repeat="(k,v) in testData.Table1[0]" value="{{k}}">{{k}}</option>
    </select>
    <br>
    <br>
    Array Element[Property]
    <input type='text' readonly value="{{ testData.Table1[selectedIndex][selectedProp] }}">
    <br>
    <br>
    Selected Array Element: {{selectedIndex}}
    <br>
    Selected Property: {{selectedProp}}
    <br>
    <br>
  </body>