Dan Bader, a Python trainer and author, writes Python tutorials on topics like memoization, DSLs, and mobile development.
HN links his Python tutorials, such as the memoization article, and a commenter recommends his Python Tricks book.
You mean resources on creating your own program synthesis system? Hm, I don't know of anything like a program synthesis toolbox, like OpenCV for machine vision, etc. There are many freely available program synthesis systems, but most are research prototypes and they only use a particular approach anyway, while I think you 'd prefer to be able to experiment with different approaches, no?
I fear the best option is to try to roll-your-own, based on the descriptions in many different program synthesis papers. Btw, I wouldn't choose neural program synthesis for a first Project! First because neural program synthesis requires as training examples both programming tasks (usually in the form of I/O examples) _and_ programs solving the tasks, and many many of them to boot. Second because it's an uncommon enough approach, or combination of approaches, that I doubt you'll find much support for it in the standard neural net frameworks.
I think the CSAIL program synthesis course suggested above by yldedly is a good starting place though. It's graded by a program synthesis project and you might find some tools meant to help students carry out their assignment on the course pages. Or you may try asking the tutors by email even.
Other than that, the simples thing to get you started is to define a DSL, generate programs from it and test them against I/O examples of the target programs. That's the simplest, most primitive kind of thing you can do. It's not a very efficient thing to do, but…
here's my other comment that talks about this: https://news.ycombinator.com/item?id=23008968
even among dynamically typed languages, python is terrible. it has no real way to build up new types in a principled way, and you have to result to using (and abusing) the class system, which is hack after hack.
python also ignored and continued to ignore things that already existed in languages and advances. it also doesn't really like using data-type driven development. go ahead and search for "python records". you'll get nothing, and the best reference is a blog post (https://dbader.org/blog/records-structs-and-data-transfer-objects-in-python) that leads you to a wide variety of solutions, all inconsistent with each other and not conventionally used. now search google and literally the top result for each query is the following:
"f# records" (https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/records)
"elixir records" (https://hexdocs.pm/elixir/Record.html)
"clojure records" (https://clojuredocs.org/clojure.core/defrecord)
"racket lang records" (https://docs.racket-lang.org/rebellion/Records.html)
another area that python doesn't take seriously is scoping. the scoping rules and exceptions are complex, and this makes the language very dangerous. i mentioned one in the other comment i linked. python has weird scoping stuff with lambdas. python even has a keyword that makes a locally bound variable available in the calling scope…
Thanks everyone, the comments are much appreciated. Here's a list of books and other media resources recommended so far in the thread:
Robert C. Martin, Clean code: https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882
Vaughn Vernon, various: https://vaughnvernon.co/?page_id=168
Steve McConnell, Code Complete: https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670 2
Clean coder: https://cleancoders.com/ videos
Hunt and Thomas, The Pragmatic Programmer: https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X
Hitchhiker's Guide to Python: https://docs.python-guide.org/
Dustin Boswell The Art of Readable Code: https://www.amazon.com/Art-Readable-Code-Practical-Techniques/dp/0596802293
John Ousterhout, A Philosophy of Software Design: https://www.amazon.com/Philosophy-Software-Design-John-Ousterhout/dp/1732102201 This one looks particularly interesting, thanks AlexCoventry!
Kent Beck, Test Driven Development: https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530
Dan Bader, Python Tricks: The Book: https://dbader.org/
Ian Sommerville, Software Engineering: https://www.amazon.com/Software-Engineering-10th-Ian-Sommerville/dp/9332582696
Svilen Dobrev, various: http://www.svilendobrev.com/rabota/
A mix of everything
- HN Digest - http://hndigest.com/
- Hacker News Books - http://hackernewsbooks.com/
- Julie Zhuo's The Looking Glass - http://www.juliezhuo.com/design/mailinglist.html
- a16z monthly newsletter - http://us7.campaign-archive2.com/home/?u=35c671b34bb404149166bf755&id=6da14709cd
- Pointer.io - http://www.pointer.io
- Changelog Weekly - https://changelog.com/weekly
- Dan Bader's python tricks - https://dbader.org/
- The New Yorker - https://www.newyorker.com/newsletters
- Android Weekly - http://androidweekly.net/
- AndroidDevDigest - https://www.androiddevdigest.com/
- GitHub Explore - https://github.com/explore/subscribe
Thanks for similar articles. I am aware of similar articles and that's why I have kept it short and simple. I will add these as references, later.
I have enjoyed reading Python Tricks[0] book by Dan bader (author of https://dbader.org/blog/python-memoization ). It's awesome. Might be outdated but I still recommend it to any body who has just started learning python.
[0] https://realpython.com/products/python-tricks-book/
Instead of the last quote in the article, I prefer this one (got it from [0])
>"There are two hard things in computer science: cache invalidation, naming things, and off-by-one errors." – Martin Fowler
And there's plenty of similar articles, for example [1] [2]
[0] https://www.mediawiki.org/wiki/Naming_things
[1] https://dbader.org/blog/python-memoization
[2] https://mike.place/2016/memoization/