Hacker News new | past | comments | ask | show | jobs | submit | saadq's comments login

Hey all, I just created https://proposals.es which, like the title says, lets you browse through ECMAScript proposals.

Some of the main features:

* All proposals are colocated in one place and sorted by stars (In the tc39/proposals GitHub repo it is split up in 6 different markdown files with proposals in no particular order) * You can filter proposals via search * Proposal READMEs as well as additional details show side by side * Proposals without a README still render as an iframe

You can find the source on GitHub: https://github.com/saadq/proposals.es. Built with Next.js, React, and TypeScript.


Really interesting to see the evolution of JS presented in this manner, thanks for sharing!


Location: Seattle, Washington

Remote: Yes

Willing to relocate: Yes

Technologies: JavaScript (ES6), TypeScript, Java, Node.js, HTML, CSS, React, React Native

Email: saadquad@gmail.com

GitHub: https://github.com/saadq

I am currently a Front End Engineer II at Amazon, and am open to both front-end and fullstack roles.


Hello,

Likewise for me, I would love if I could reach out to you. I had applied awhile back and hadn't gotten a response, and did not have any way I could mention that I saw the post here. Would be greatly appreciated, thanks.


Hey, big fan of what you all are doing. Is charity: water open to hiring new grads who have had a lot of experience with internships/side projects?


This post says that you're hiring Full stack devs, but there don't seem to be any any full-stack positions available in the angel.co list of jobs.


Thanks for the suggestions! I'll try to improve the contrast. As you mentioned, most of the templates I chose were the popular ones from sites like ShareLaTeX and Overleaf. I am happy ot add more templates, if someone were to open a "Template Request" issue on the repo.

And yeah, I was hoping to add import/export to json as well as an "import from LinkedIn" functionality.


Thanks! I was definitely planning on adding an import/export feature so that you don't have to keep starting from scratch, so I can try to see if I can make it compatible with jsonresume too.


Hmm, maybe it isn't completely intuitive. You actually need to click on the menu at the top right to navigate between sections on mobile.


Oh that's a very odd UX. I'd suggest at least a previous next button on each page. But keep the menu for global navigation.

Nice site.


Yep, that's a good idea. And thanks!


Hey all! latexresu.me is a website for generating LaTeX resumes easily.

Basically, you just choose a template, fill in as much (or as little) info as you want, and click "Preview Resume" at any point to see your current generated PDF. You can switch your template on the fly at any point and once you're happy with your results you can download the PDF or the generated LaTeX source code. Please let me know what you guys think!

Source Code: https://github.com/saadq/latexresu.me


Not really a fan of the lambda syntax in Python. Comparison:

JavaScript:

  let arr = [1, 2, 3]
  let sumOfSquares = arr.map(n => n * n).reduce((a, b) => a + b) // 14
Python:

  arr = [1, 2, 3]
  sum_of_squares = reduce(lambda a, b: a + b, map(lambda n: n * n, arr)) # 14


Is there a more Pythonic way to do it? Lambdas are cool but usually not the first place you go in Python. I would think something like (my best guess, not a Python pro)...

    sum_of_squares = sum([x*x for x in arr])
Which I think is easier to read than either example post above.

Of course you will point out that this is less powerful than full map and reduce.. but meh... pros and cons to both styles


I would write it like this, to avoid constructing the immediate list:

    sum_of_squares = sum(x*x for x in arr)
This makes use of https://www.python.org/dev/peps/pep-0289/


Thanks for the link, this is good to know.


Worth noting that map() can be parallelized whereas a list comprehension can't necessarily (since it is an explicit loop). The multiprocessing module allows trivial map parallelization, but can't work on list comprehensions.

It's more than just stylistic.


So I have coded everything from dumb web servers (tm), to high performance trading engines (tm). I have toyed with doing the list in parallel thing... and used it in a toy GUI tool or two I wrote... but never really found it that useful in the real world. If you actually want high performance, doing a parallel map is not going to be fast enough. If you are a dumb web server, it's a waste of overhead 99% of the time.

But hey, if you want to use map when you actually need to do a parallel map, cool. But seems very very uncommon. ~ 1 in 10,000 maps I write.


I don't think this is the case, list comprehensions can be expressed as syntax sugar over list functions, it's how they work in Scala for example

http://docs.scala-lang.org/tutorials/FAQ/yield.html


map() can only be parallelized if the function has no side effects. If there are no side effects, list comprehensions can be parallelized just as well


That example works only because the function sum is already defined in Python. If you wanted to do something less common than summing up elements you would have to either use reduce or implement a for loop.


In Python 3, reduce was intentionally moved into the functools library because it was argued that its two biggest use cases by far were sum and product, which were both added as builtins. In my experience, this has very much been the case. Reduce is still there if you need it, and isn't any more verbose. The only thing that is a little bit more gross about this example is the lambda syntax; I would argue that even that is a moot point, however, since Python supports first-class functions, so you can always just write your complicated reduce function out and then plug it in.


True, but I've used python a lot, and I've used reduce maybe...twice? (well, twice that I can find on my github at least)


I just counted the number of reduce I used in my current python project (6k lines). reduce comes up 32 times. And by comparison, map is used 159 times and filter 125 times - for some reason I tend to use list comprehensions less than I should.


I also thing you use map not a ton if you get the list comprehension syntax down... it is a map with less cruft mostly...


curious how often reduce is used with something else than operator.add?


One occurence was to calculate the GCD of a list of polynomials.

In fact I had "reduce" appearing in the names of some of my variables so I used it less than 32 times, about 20 times in that project.


I see nothing particularly inspiring in the examples posted on http://stackoverflow.com/questions/15995/useful-code-which-u...

Could you show your reduce calls?


They are very similar to this one from your link: http://stackoverflow.com/questions/15995/useful-code-which-u...


Well, or write a static method somewhere that you call. Sum is used a lot, so handy it is written somewhere (vs having to do a lambda x + x thing.


That seems like an argument against lambda functions in general - why use lambdas when you can define a static function for every case? Well, the answer in my opinion is because it makes code more readable if you can define a simple lambda function instead of having to name every single function in the code base.


Well if you are going to reuse the function, name it. If it is a 1 time thing, use a lambda.


Sounds great in theory. Problem is if you need a lambda that isn't a single expression, you then have to name it. Welcome to the conversation.


What's the advantage of list comprehension over lambdas (assuming the lambda syntax is decently lightweight)?

I feel like I come down hard on the side of lambdas, but I've never really spent enough time in a language with list comprehension, so there's a good chance I'm missing something.


how can you come down hard on the side of one when you've never experienced the other?

I'm from a non-list-comprehension background too, but recently started working a lot in a large python codebase, and have found the dict/list comprehensions to be beautiful. I'm a huge fan. It's a shame lambda syntax is not the best and it's generally crippled, but comprehensions are a great 80/20 compromise for handling most cases very cleanly.


I find it a lot easier to read, part of which is that I'm used to the Scala way of sequence dot map function. When I see the python one I can't remember if the function comes first or the array.


I'm not positive, but I think it saves the need to create a new execution frame for each lambda call, since the whole loop executes in single frame used by the comprehension.

In theory I suppose the VM could have a map() implementation which opportunistically extracts the code from a lambda and inlines them when possible; but doubt CPython does that. OTOH, I'd be surprised if PyPy doesn't do something like that.


Since Python 3, both generators and lists create a new stack frame. [1] (2nd to last paragraph)

[1] http://python-history.blogspot.com/2010/06/from-list-compreh...


I'm not meaning when the comprehension is invoked, but during each iteration of the loop within the comprehension.

When doing something like `map(lambda x: 2+x, range(100))`, there will be 101 frames created: the outer frame, and 100 for each invocation of the lambda.

Whereas `[2+x for x in range(100)]` will only create 2: one for the outer frame, and one for the comprehension.


I think it's just less to type really, and it's considered the more standard way to do it.


For simple mathematical operations you can import them as functions:

    from operator import mul, add
    arr = [1, 2, 3]
    sum_of_squares = reduce(add, map(mul, arr, arr))


It's even more concise in Clojure:

    (defn sum-of-squares [a] (reduce + (map #(* % %) a)))
    (sum-of-squares [1, 2, 3]) ; => 14


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: