DEV Community: John Paul Ada

💪 UNBREAKABLE Code with ChatGPT!

John Paul Ada — Mon, 24 Apr 2023 06:42:01 +0000

TL;DR Video

If you're not using ChatGPT yet as a programmer, YOU ARE MISSING OUT!

I'll show you one of my favorite tricks for using ChatGPT: Using ChatGPT to write property-based tests!

Property-based tests, A.K.A PBTs, allow you to run hundreds of unit tests with just a single PBT. It does this by making you define a property of a function, then runs it with the full range of your inputs, and if your function fails the test, a PBT would find the smallest value that would fail that function.

Theoretically, if you were able to test all the properties of a function, then your function is now UNBREAKABLE! This is because the properties of your functions is the definition of your function: if your definition is perfect, then the function is perfect!

Oooookay so I think that's a bit confusing so let me show you an example instead!

Suppose we have an addition function:

def add(a, b):
  return a + b

How we'd usually test this is do something like:

def test_add_1(a, b):
  assert add(1, 1) = 2

But what if a weird dev used this implementation instead?

def add(a, b):
  return 2

Obviously this would pass the test, but would fail in other instances.

This is where unit tests fail. You can't possibly manually write every possible test for every possible input. With property-based tests, you can achieve this by testing the function properties themselves.

What you can do instead is to test the properties with Property-based Tests.

One of the properties of addition is the identity property. Whatever number you add to zero, it will return that number.

To test for that we can do something like this:

@given(st.floats())
def test_add_identity(a)
  assert add(a, 0) == a

What this will do is that for all float values, it will test if adding that to 0 will always return itself. With the weird implementation, if a is 2 then it works, but then the PBT will continue testing for other values until it encounters an issue.

Now this obviously still has loopholes, but if you manage to test for all properties, like the commutative, associative, etc. then you'll have an unbreakable function.

Now we understand how powerful these tests are. Let's use ChatGPT to do this for a more complex example!

Let's use this naive Pearson r implementation:

def pearson_correlation_coefficient(x_values, y_values):
    x_mean = sum(x_values) / len(x_values)
    y_mean = sum(y_values) / len(y_values)

    covariance = sum((x - x_mean) * (y - y_mean) for x, y in zip(x_values, y_values)) / len(x_values)
    stddev_x = (sum((x - x_mean) ** 2 for x in x_values) / len(x_values)) ** 0.5
    stddev_y = (sum((y - y_mean) ** 2 for y in y_values) / len(y_values)) ** 0.5

    return covariance / (stddev_x * stddev_y)

This has glaringly obvious bugs but assume that you don't know for now.
To write Property-based tests for these, we can do use this ChatGPT prompt:

Create property-based tests for the following code. Please be comprehensive and test all properties and cases, especially those that will make the function fail. Make sure to thoroughly document the properties being tested using docstrings. Use library as test library.

Code:
insert code

Together with the function we have, the complete prompt will look something like this:

This prompt generated these property-based tests for me:

import pytest
from hypothesis import given, strategies as st

@pytest.fixture()
def pearson_corr():
    return pearson_correlation_coefficient

@given(st.lists(st.floats()), st.lists(st.floats()))
def test_pearson_correlation_coefficient_valid_input(pearson_corr, x_values, y_values):
    """
    Test the pearson_correlation_coefficient function with valid input.
    It should return a value between -1 and 1, inclusive.
    """
    if len(x_values) < 2 or len(y_values) < 2:
        with pytest.raises(ZeroDivisionError):
            pearson_corr(x_values, y_values)
    else:
        result = pearson_corr(x_values, y_values)
        assert -1 <= result <= 1

@given(st.lists(st.floats(min_value=-100, max_value=100), min_size=2), st.lists(st.floats(min_value=-100, max_value=100), min_size=2))
def test_pearson_correlation_coefficient_identical_inputs(pearson_corr, x_values, y_values):
    """
    Test the pearson_correlation_coefficient function with identical inputs.
    It should return 1.
    """
    result = pearson_corr(x_values, x_values)
    assert result == 1

@given(st.lists(st.floats(min_value=-100, max_value=100), min_size=2), st.lists(st.floats(min_value=-100, max_value=100), min_size=2))
def test_pearson_correlation_coefficient_negative_identical_inputs(pearson_corr, x_values, y_values):
    """
    Test the pearson_correlation_coefficient function with identical inputs but with one list negated.
    It should return -1.
    """
    y_values_neg = [-y for y in y_values]
    result = pearson_corr(x_values, y_values_neg)
    assert result == -1

@given(st.lists(st.floats(min_value=-100, max_value=100), min_size=2), st.lists(st.floats(min_value=-100, max_value=100), min_size=2))
def test_pearson_correlation_coefficient_orthogonal_inputs(pearson_corr, x_values, y_values):
    """
    Test the pearson_correlation_coefficient function with orthogonal inputs.
    It should return 0.
    """
    x_values_orth = [y for y in y_values]
    result = pearson_corr(x_values, x_values_orth)
    assert result == 0

@given(st.lists(st.floats(), min_size=1), st.lists(st.floats(), min_size=1))
def test_pearson_correlation_coefficient_zero_division_error(pearson_corr, x_values, y_values):
    """
    Test the pearson_correlation_coefficient function with inputs that have zero variance.
    It should raise a ZeroDivisionError.
    """
    with pytest.raises(ZeroDivisionError):
        pearson_corr(x_values, y_values)

@given(st.lists(st.floats()), st.lists(st.floats()))
def test_pearson_correlation_coefficient_same_length(pearson_corr, x_values, y_values):
    """
    Test the pearson_correlation_coefficient function with inputs that have different lengths.
    It should raise a ValueError.
    """
    x_values.pop()
    with pytest.raises(ValueError):
        pearson_corr(x_values, y_values)

As you can see, with ChatGPT, it is VERY EASY to generate tests that will bug-proof your code. I use this almost everyday in my work as a data engineer. Now then, try this out with your own code and prepare to be amazed!

If you liked this, Like and Follow me here on Medium - Subscribing to my YouTube would help me a lot as well! Thank you!!! 💚

How to Create Jobs With Multiple Tasks in Databricks

John Paul Ada — Fri, 15 Oct 2021 13:29:02 +0000

Original Blog Post: My Blog - How to Create Jobs With Multiple Tasks in Databricks

Note: This video is in Filipino/Tagalog.

When working with data it's very useful to be able to create data pipelines where we can have tasks in a pipeline run in sequence or in parallel or have dependencies witch each other, where the next tasks will only run when their dependencies or previous tasks have finished running.

To accomplish, usually we'd use external task orchestrators like Airflow, Prefect, Nifi, or Oozie.

In the version of Databricks as of this writing, by default we are unable to create jobs with multiple tasks as shown here:

But there's a way to add multiple tasks to a job in Databricks, and that's by enabling Task Orchestration. At the time of this writing, Task Orchestration is a feature that's in public preview. This means that it's currently available for everyone, but it's not enabled by default.

To enable it we first go to the the Admin Console:

Then go to Workspace Settings tab:

Then we'll search Task on the search bar. We'll then be able to see the switch for Task Orchestration:

It might take some time to take effect but once that's enabled, we will now be able to see a button for adding another task to our job:

After that we can just add a task similar to what we're used to. The only difference is now there is a Depends on field where we can specify the dependencies of our current task:

Once we're done adding that, we can run our job and see something like this when it's complete!

And that's a wrap! I hope this helps you setup your own data pipeline in Databricks!

🔥 #overengineeringchallenge 🔥

John Paul Ada — Wed, 03 Apr 2019 14:13:59 +0000

Rationale 🤔

Overengineering has always been the pet peeve of many developers. We engineers have this tendency to descend into the chaos of adding nice-to-have features or architecting to support things that might happen in the far future. To avoid this, we create constraints for the project and work around these constraints.

But what if we break out of this for once? What if we do the OPPOSITE?

That's where this challenge comes in.

The Challenge 💪

The challenge is to create a TODO List App and overengineer it to its limits.

Make it with the most overkill tech you know.
Use the most exotic techniques that you can wield.
Build it with the most overblown architectures.
Design with the insanest user experience.

FORK THIS PROJECT and let your imagination run wild. There are no limits to what you can do.

JUST OVERENGINEER™.

YOU HAVE THE LICENSE TO DO IT.

Example 📜

Here's my idea of what I'd do when I do this challenge:

Create an Elixir GraphQL API using Absinthe
Create the web application frontend using ReasonReact
Use Kubernetes to stitch together the web application
Create a mobile app using Flutter or bs-react-native

Social 💻

Add a hashtag #overengineeringchallenge when you share your project on social media!

When you're done, make a Pull Request and add yourself to the list of challengers! 🔥

Github Repo

johnpaulada / overengineeringchallenge

🔥 THE #overengineeringchallenge.

🔥 Over Engineering Challenge

Rationale 🤔

But what if we break out of this for once? What if we do the OPPOSITE?

That's where this challenge comes in.

The Challenge 💪

The challenge is to create a TODO List App and overengineer it to its limits.

Make it with the most overkill tech you know.
Use the most exotic techniques that you can wield.
Build it with the most overblown architectures.
Design with the insanest user experience.

FORK THIS PROJECT and let your imagination run wild. There are no limits to what you can do.

JUST OVERENGINEER™.

YOU HAVE…

View on GitHub

What do you think about the challenge? Please comment below!

✨ ALL CONTRIBUTORS ARE WELCOME! ✨

Pop Tech TL;DR Episode 2 - Combatting bad clients, better npm packing, meaningful tech jobs, and more!

John Paul Ada — Sat, 16 Feb 2019 16:42:39 +0000

Originally posted at: https://devstuffwithjpada.com/pop-tech-tldr-episode-2/

Not Paid

Did your client forget to pay? Fade out the website each day they don’t pay until it completely disappears! Pro Tip: Mix it with the code, minify, and obfuscate for greater effect. *winks

x0

x0 is a tool that allows you to create documentation for your React components. Think of it as an alternative to StoryBook. One of the most interesting features it has is the LiveEditor, allowing you to play around with the components in a live environment and being able to see a preview of the change immediately.

Brisk

Brisk allows you to use ReasonML/OCaml to create native UIs. It’s still a work in progress but it’s exciting to see how it’s gonna end up, especially since it’s using Reason.

JAMstack WTF

The JAMstack is wildly popular right now. This site will help you understand WTF JAMstack really is and why developers are currently all about trying to build their apps with this technology stack. It also teaches some best practices and an ideal workflow. Now go over there and be one of the JAMstack-savvy developers!

Positive Impact Tech Jobs

If you’re looking for a job, how about you consider applying for one that has positive impact on the world and its people? Positive Impact Tech Jobs is a listing of tech job opportunities in companies that try to make a positive change in the world. They have a listing for companies with social impact, education impact, environmental impact, healthcare impact, et cetera. Companies like Khan Academy, John Hopkins University, and OpenAI have job opportunities posted on the listings. If you ever want to work for a company that champions social good, this is a great place to start.

@pika/pack

This tool is one that I am personally very excited to try out. @pika/pack is a CLI tool that allows you to simplify the process of packing and deploying an npm package. @pika/pack lets you create a pipeline of the common processes you do with a library such as compiling to ES5, uglification and the like, using plugins with sensible defaults. Once you’ve setup your pipeline, just run pack build && pack publish and you are done!

We are Colorblind

We are Colorblind is a site that educates people about colorblindedness and gives insights, tips, and resources to help people develop content and software that are colorblind-friendly.

Pop Tech TL;DR Episode 1 - A review of tech about APIs, JavaScript search, SVG, GraphQL, Testing!

John Paul Ada — Sat, 09 Feb 2019 18:30:36 +0000

Originally posted at https://devstuffwithjpada.com/pop-tech-tldr-episode-1/.

Hey guys! I'm starting a new series called Pop Tech TL;DR, where we'll take a look at popular technologies, concepts, advances, and trends in the world of software engineering. This episode will be the first in the series.

1. Learning to work with APIs

This guide is designed for people who have something they want to accomplish that requires using an API, but aren't quite sure how to get started.

This site will teach you how to use REST APIs, which are a must if you want to get information or use services created by other people. It talks about authentication, requests, responses, tools, etc. If you want to learn how to consume REST APIs, check it out! It's really easy to understand.

2. FlexSearch.js

Web's fastest and most memory-flexible full-text search library with zero dependencies.

FlexSearch is a new JavaScript library for almost everything you'd want in text search functionality. It's full featured, supporting things like async search, partial matching, phonetic matching, and more! Apparently it's also really really fast, but as always, take everything with a grain of salt and actually try it out yourself to see if their measurements really do check out.

3. Everything You Need To Know About SVG

Using SVG can be very simple, but if you start digging in, there is a lot to know about SVG. In this series you're going to learn why SVG is such an important part of building websites. From why SVG is useful and how to get your hands on it all the way to implementing it as a system and fancy stuff like animating it.

CSS Tricks just updated the look and feel of their site and man, is it gorgeous. Very fitting, being the CSS masters that they are. This new course they have about SVGs is no exception. It look so slick, elegant, and modern. Of course, the content is very important, and they have videos on what SVGs are, why we need them, how to use them, tools, optimizations, and tips to really help you understand SVGs in-depth. Designer or not, it's a pretty awesome course to check out.

4. GraphQL Designer

A developer web-app tool to rapidly prototype a full stack implementation of GraphQL with React.

Pick a database, create a schema, export your code and voila!
GraphQL Designer is a rapid GraphQL API design and prototyping tool that allows you to pick a database, create a schema, then convert the schema you made into working code! You'll download the database schema, the GraphQL schema, and client code for making requests to your GraphQL API. Great for prototyping in hackathons or if you're building simple or straightforward apps. In any case, if you work with GraphQL, you might want to check this out.

5. React Testing Library

Simple and complete React DOM testing utilities that encourage good testing practices

The prolific React and JavaScript developer Kent Dodds created this library as an alternative to Enzyme. It gives us less flexibility because it's opinionated, but this also means that we're going to be implementing best practices by using it. Less options means we have less rope to hang ourselves. Kent already has a tutorial video on how to use it on YouTube but I think I'll cover it in Filipino for all my Filipino developer peers out there. Definitely look forward to it!

This Week I Learned #9

John Paul Ada — Thu, 27 Sep 2018 14:48:08 +0000

Fun stuff and announcements about testing, Python, ReasonML, etc. in this episode of This Week I Learned!

Cypress

Fast, easy and reliable testing for anything that runs in a browser.

Cypress is a new way to your web applications. Personally, I think it replaces my use cases for Selenium and it is faster, prettier, and easier to use. Here are my favorite features of Cypress:

Doesn't use a WebDriver.
It has a pretty GUI.
You use JavaScript to write Cypress tests.
The assertion syntax is similar to other JavaScript testing libraries like Chai and Jasmine.
You don't need to explicitly tell it to wait. It automatically does so.
The tests reload when you change your test code.
You can see the tests as they happen and you can step back through the testing process.
It creates a video of the testing process if you run it without the GUI.

face_recognition

The world's simplest facial recognition api for Python and the command line

If you want to do facial recognition and you know Python, look no further. Adam Geitgey's face_recognition library is very easy to use and pretty accurate. Just look up the docs and you'll immediately know what you need to do.

Sketch.sh

If you've used Jupyter notebooks before for Python or R, or RunKit, ObservableHQ Scratchpad, and Kajero for JavaScript, you'd agree that they're pretty neat platforms for experimentation and sharing your work.

If you're into Reason and those kinds of notebooks, you'll be pretty happy with Sketch.sh. Sketch allows you to create ReasonML and OCaml interactive notebooks. This would be great if you want to teach and learn ReasonML interactively especially since it is pretty new.

Doc Tests in Elixir

Have you ever wrote documentation and found out that the code examples in your documentation no longer work because the code was updated?

Elixir eliminates this problem by having what we call doctests. Basically, when you add code snippets in your documentation and you configure it to work with doctests, Elixir (ExUnit, specifically) will make sure that the snippet works. If the value isn’t as expected, the tests will fail. This makes sure that the documentation you have actually matches the software you have written.

Pretty cool! Another reason to switch to Elixir! 😄

mdx-deck

If you’re a geek like me, you like creating slides with code because it’s cool! But building it in something like HTML is a bit time consuming and complicated so we sometimes just resort to using Markdown to make things simple. But Markdown isn’t omnipotent. If you want to add interactivity, it’s game over.

Luckily there’s mdx, which allows us to create Markdown documents with JSX! Now we can add interactivity and “web components” in to our documents. Now, mdx allows us to create interactive documents, but what about slides? mdx-deck solves that problem for us by allowing us to create slide decks using mdx syntax. So we can create some React components and show them in action in our slides. You can even change the theme using the ones included or create your own theme. Have fun making your slides with mdx-deck!

reason-maybe

I’ve been playing around with ReasonML for a while and so it doesn’t come as a surprise that I tried building a library in Reason. So, I built reason-maybe, which is a Maybe monad implementation in Reason. For most cases, you can just the optional type in Reason but if you want chains/flatMaps, etc., this is a pretty okay one to try.

Stencila

Stencila is another interactive notebook software for building reproducible research. This combines something like MS Excel and Word, plus the ability to code in Python and Node. It also looks a bit cleaner. This is definitely a pretty interesting one to try, although I feel that it isn’t quite ready yet. But do definitely give this a try.

DryStack

If you have difficulty picking the stack for your project, or you don’t know what your choices are, you can try out DryStack. You can check out some tech stack options for client, server, tooling, etc. If you don’t know where to start, this is a pretty good starting point.

FlacheQL

GraphQL is a young piece of technology and there are still a lot of problems with no industry standard method of solving. One of those problems in caching. While Facebook has created a solution for this, namely dataloader, it only caches exact requests. A new contender, FlacheQL, allows partial retrieval of a cached result. This is definitely pretty nice because you don’t have to fetch everything if the query does not exactly match the query that was cached. This will make caching with GraphQL more efficient.

Kore

If you’re bored with the usual PHP/Java/C#/Node approach to developing web APIs and want something more hard core, try out Kore! It allows you to build web APIs in C.

IN. C.

If that isn’t hardcore enough, I don’t know what your definition of hardcore is.

But still it is an interesting concept, and we all know how fast C is. So definitely try and check this out, if you dare.

This Week I Learned #8

John Paul Ada — Thu, 05 Jul 2018 08:13:18 +0000

JavaScript, Python, Reason, and more! Fun tech stuff to look forward to!

JavaScript Proxy

Proxies in JavaScript allow us to add hooks to objects. For example, when a value in an object is being extracted or being set, we can execute some side-effect or override the value being returned. This is helpful if you want to do some simple pub-sub actions, e.g. informing other objects if an object's value has changed. This can also be helpful if you want to do validation, e.g. the value in the object will remain the same if the value it was set with was invalid. This is a very powerful feature so check it out and see what creative ways you can use JavaScript proxies in!

Here's a basic validation example from MDN:

let validator = {
  set: function(obj, prop, value) {
    if (prop === 'age') {
      if (!Number.isInteger(value)) {
        throw new TypeError('The age is not an integer');
      }
      if (value > 200) {
        throw new RangeError('The age seems invalid');
      }
    }

    // The default behavior to store the value
    obj[prop] = value;

    // Indicate success
    return true;
  }
};

let person = new Proxy({}, validator);

person.age = 100;
console.log(person.age); // 100
person.age = 'young'; // Throws an exception
person.age = 300; // Throws an exception

FormSpree

One of the things that throw you off when you want to create a landing page or just a simple static homepage is the issue of forms. Where would you send them if you don't have a server?

FormSpree deals with that problem by receiving the data from the form and forwarding the data to your email. It has a pretty okay free tier and for unlimited amounts of emails you just have to pay $10 per month.

<form action="https://formspree.io/your@email.com"
      method="POST">
    <input type="text" name="name">
    <input type="email" name="_replyto">
    <input type="submit" value="Send">
</form>

for-await-of

Sometimes it's helpful to put Promises in an array and loop through their resolved values, like when making a lot of requests via fetch or axios. When dealing with an array of Promises, we usually use Promise.all to make sure they're all resolved, right? The problem with this is that it will wait for all of the Promises to resolve first before we can actually work with them. What we want is to get each request and start working with them the moment they resolve. How do we do that? We can use the for-await-of JavaScript syntax.

Here's an example from from Dr. Axel Rauschmayer's blog. Basically instead of using Promise.all like this:

for (const x of await Promise.all(syncIterableOverPromises)) {
    // Do something with x
};

we do this instead:

for await (const x of syncIterableOverPromises) {
    // Do something with x
};

This will get each x in the syncIterableOverPromises iterable and then wait for it to resolve then proceed to the body of the for loop to work with the resolved x. This makes it easier to start working with a list of Promises without waiting for all of them to complete.

Clementine

If you have difficulty trying to build your application specs and the cost for building the application, you can use Clementine for that! Clementine guides you through the process of building your app specs, and at the end, estimates how much building the application would cost.

Vibora

If you like building Web APIs with Python with Django or Flask, why not take Vibora out for a spin? Vibora is a new web framework for building fast APIs, faster than most of the popular Python web frameworks out there. Inspired by Flask, Vibora is pretty easy to use and it is fully asynchronous. Check out their benchmarks on their site to see for yourself!

Transfer.sh

If you want to share files for free without leaving your terminal, transfer.sh is the thing or you! If you the installation instructions, you'll have a transfer binary that you can run to upload a file. After uploading, you'll be presented with the download link you can send to your friends! The link lasts for 14 days and can be as big as 10 GB. The best thing is that it's free! Check it out!

Sail CI

If you want a hosted CI solution that's cheap, easy to use, and has a great free tier, check out Sail CI! You have 1000 build minutes per month which is already good enough compared to most hosted solutions out there. It's also pretty to setup! Just go to your project directory, run sail init , define your pipeline in a .sail file and you're all set!

It currently only supports Github, but we'll probably see support on the others like Gitlab and Bitbucket in the near future!

Why do I Procrastinate

This site asks you some questions and figures out why you're procrastinating. After that, it gives you recommendations on what to do to stop procrastinating and start working!

ML5.js

TensorFlow.js took the web world by storm but to some still feel it is complicated even for common tasks. ML5.js makes this simpler by having a relatively easier API for dealing with common tasks like image classification. If you've been itching to do Machine Learning on the web, try this out!

Mkcert

When developing for the web, sometimes we need to test our applications with HTTPS enabled. The problem is that most of the time, that is difficult - so features that require HTTPS to work can't be tested on locally. Mkcert helps us with this problem by being a zero-config tool for creating certificates for HTTPS. Next time you need HTTPS for local testing, try Mkcert out!

Get HTTPS for Free

Let's be honest - the process of getting a certificate from Let's Encrypt is not a piece of cake. Get HTTPS for Free helps you create your own certificates and get them signed with Let's Encrypt with relatively easy to understand instructions - and all you need is a terminal window and the single page of the site. The site doesn't look too great, but it works!
Side note: I'm trying to recreate the site with another design - if you want to help me out here: https://github.com/johnpaulada/gethttpsforfree-redesign!

Railway-Oriented Programming

When developing applications, we usually focus on the happy path - on how the application should be behaving, but when you think about it, errors are also part of the program. Therefore, we also have to assume errors are going to happen and assume that there will be two paths: the happy path and the failure path. That's what Railway-Oriented Programming is all about. Our program should always take those two paths in consideration. Check it out if you're interested! 😄

ReasonML Philippines

ReasonML is an awesome language created by Jordan Walke, the same guy who created React at Facebook. I've been very interested in it since the time I heard it last year during ReactConf 2017 during Cheng Lou's talk. I noticed that there weren't a lot of ReasonML enthusiasts in the Philippines - heck there wasn't even a Facebook group! So I created one! If you're from the Philippines, or even if you're just plain interested in ReasonML, please join us in the group! 😃

It's my Dev.to anniversary! Here are some stuff!

John Paul Ada — Tue, 05 Jun 2018 08:23:55 +0000

It's my one year anniversary at Dev.to! 🎉

I received an email today saying I got the beloved comment badge so I visited my Dev.to profile page and saw that I joined Dev.to this day last year!

Good Stuff

To thank the community, here are some of my favorite resources:

Awesome Learning Resources

This is my own collection of resources, inspired by the Awesome collections. I'm sure you're familiar with them. This one is a collection of learning collections. Meta af, am I right?

Alcamy Data Science Topic

This is a topic on Alcamy that I also compiled. This is my main study guide when it comes to Data Science. I update this whenever I find a good resource to add to the list.

Github Trending Page

A list of the day's trending repositories. You can also filter it by date range (week, month), language used, etc.

StackShare News

This site collects tech news from a range of sources like Reddit, Medium, HackerNews, etc. You can specify which technologies you would like to display news for.

Vue HN 2.0

A web app that pulls data from HackerNews and displays preview of the page.

Bonus: My Anchor Podcast: The Random Programmer - I talk about a bunch of stuff about programming and software development.

This Week I Learned #7

John Paul Ada — Tue, 29 May 2018 13:43:16 +0000

Logic, Promises, NPM, PHP, ML, and a bunch of other acronyms in this episode of This Week I Learned!

This was originally posted on Medium.

De Morgan’s Laws

The rules can be expressed in English as:

the negation of a disjunction is the conjunction of the negations;

and the negation of a conjunction is the disjunction of the negations;

The De Morgan’s laws are a set of rules that allow us to transform a logic expression. I use these to make my boolean expressions simpler.

Promise.notAll/Promise.allMost

Sometimes you need a list of Promises and you want them all to complete then return the array with the expected values. You’d usually use Promise.all for this in JavaScript, right? But what if one of the Promises rejects but you still want to get the ones that succeeded on their respective positions?

We encountered this problem so we built Promise.notAll! We also called it Promise.allMost (get it?) thanks to Kurt Jerome Obispo’s suggestion. Anyway, here’s the code for it.

And here's how you'd use it:

npm --

This enables you to add arguments to your call to an NPM script. For example, if you have an npm script called test and would like to add a verbose flag to it, then you can do:

npm run test -- --verbose

npm audit

npm audit analyzes your dependencies and lists the vulnerable packages and their level of severity. You can even see the link to the security report on the vulnerable packages! This makes it easier to secure our node applications.

Ow

Ow! is a library for Function argument validation for humans built by the prolific Sindre Sorhus. It‘s batteries-included and has a great chainable API. You can also use create your own validator if you want! All in all, this would help you keep your code away from bugs and malicious input.

:: placeholder

Apparently you can style textbox placeholders! I didn’t know that. LOL. But apparently you can use the ::placeholder pseudoselector to select placeholders and style them with CSS.

ML .NET

Just install the Microsoft.ML package and enjoy the power of Machine Learning whether you’re using C# or F# or whatever language that uses the .NET framework! I don’t have much to say about this so just jump right in and try it out instead! 😆

Rendertron

Rendertron is a dockerized, headless Chrome rendering solution designed to render & serialise web pages on the fly.

Rendertron is Google’s answer to Prerender, which allows you to render your SPAs and that’s what’s served to search engines for SEO and indexing purposes. So you basically spin up a server running Rendertron server and you access the site via the rendertron server. The server will request your real web app and will display it when it has completely loaded. You can let Rendertron decide when the site has loaded or you can explicitly set it. To know more about Rendertron, visit their Github repo.

PHP UI

Yep. You’re seeing it right. You can actually build cross-platform desktop applications with PHP! It’s in the official documentation folks! In the introduction:

This extension wraps libui to provide an OO API for the cross platform development of native look-and-feel user interfaces .

Who says PHP is only for the web? 🙊

Kubernetes Autoscaling

Last time I checked when you setup Horizontal Pod Autoscaling for Kubernetes, you use the CPU usage as the metric. Now you can use the RAM usage, HTTP requests, or other metrics as the trigger for when you would automatically scale your Kubernetes cluster. That is pretty great news!

GraphCool Continuous Deployment with Bitbucket Pipeline

John Paul Ada — Mon, 14 May 2018 10:32:25 +0000

This was originally posted on the GAPLabs Engineering Blog.

If you can automate it, you should.

We all try to live by this, but it’s not always easy. Automation is not the easiest thing to do. But it should be. And continuously deploying a GraphCool server with Bitbucket Pipelines is. Because we use Bitbucket everyday, it’s a no-brainer that we’d use Bitbucket Pipelines as our service of choice.

In order to deploy a GraphCool server, we just need to do these steps:

Install the GraphCool CLI.
Install dependencies.
Run graphcool deploy.

bitbucket-pipelines.yml

That’s it. Just include this bitbucket-pipelines.yml file in your root directory and push some changes to the master or dev branches. It will then begin the build and deploy. If you think this is confusing, here’s a little breakdown.

Breakdown

This pipeline uses the johnpaulada/graphcool image as its runtime image, which is just a Node image with the GraphCool CLI installed. This takes care of the step 1 above.

After loading the image, it will then start installing the dependencies with Yarn. This takes care of step 2. If the yarn.lock or package.json have not changed, Pipelines caches the node_modules folder, making the installation process faster.

After that, graphcool deploy is run, which starts the deployment process. It knows where to deploy it from the GRAPHCOOL_TARGET environment variable. If deploying to dev, we use the GRAPHCOOL_TARGET_STAGING instead. This takes care of step 3.

Environment Variables

We need the GRAPHCOOL_TARGET, GRAPHCOOL_PLATFORM_TARGET, and GRAPHCOOL_TARGET_STAGING environment variables. You can get the GRAPHCOOL_TARGET and GRAPHCOOL_TARGET_STAGING from your .graphcoolrc file. The GRAPHCOOL_PLATFORM_TARGET is in your ~/.graphcoolrc file.

This Week I Learned #6

John Paul Ada — Sun, 06 May 2018 09:09:24 +0000

This is part 2 of the back-to-back podcast episodes! 😉

I’m recording this podcast episode from Sambawan Island. 😄

Readrr

I saw this cool app called Spdr which allows you to speed read by copy pasting words on to the app and displaying the words one by one. It’s free so I tried to download it but apparently I can’t because you need to have iOS 11 and I’m still on 10 (can’t upgrade coz I got no space left).

So I had my sister do a quick mockup of what the site would look like on Gravit and I implemented it. It looks like this because of my sister’s taste for design. It’s free and open source, so you can check it out here and maybe checkout the repo.

Angular 6

The 6.0.0 release of Angular is here! This is a major release focused less on the underlying framework, and more on the toolchain and on making it easier to move quickly with Angular in the future.

WebAssembly Studio

WebAssembly Studio is a web-based IDE for writing WebAssembly in C, Rust, etc. You build it out in a different language, run it, and then build a .wasm file when you’re ready. This makes using WebAssembly to build applications less daunting.

MailTrain

If you have a spare server lying around and MailChimp is not your thing, you can try out MailTrain!

VS Code Can Do That

If you’re new to Visual Studio Code try this out! The site teaches you fun and awesome features that you probably didn’t expect a code editor like VS Code to be able to do.

Stdlib.io

Despite being a very popular language, JavaScript does not have a standard library like C++ and Python. Stdlib.io is a project that aims to be a standard library for JavaScript. It has functions for math, for data structures, and even for plotting! The downside is that the library has pretty bad documentation and it’s pretty large — so large that I can’t use Jsdelivr as a CDN because it can’t process it. Other than that, it’s pretty awesome.

Plover

If you’ve ever tried Apple’s AirDrop, it’s probably your choice of quickly sending files to nearby devices. Plover is an alternative for people who do not have Apple devices. Head on over to plover.io and find the person you wish to send the files to and there you go! You have to be connected to same network though.

Mode Studio

If you work with data either at work or as a hobby, Mode Studio is a great tool to try out. It allows you to work with Python, R, and SQL seamlessly in a Jupyter notebook-like environment. Best of all: it’s free! What’s not to love?

This Week I Learned #5

John Paul Ada — Tue, 24 Apr 2018 10:12:39 +0000

TensorFlow, Kubernetes, and more in this exciting episode!

It’s been a while guys! I’ve been pretty busy because there’s a lot going on, from giving a talk at TensorFlow Dev Summit Extended Manila 2018 to starting new projects.
So I’m going to release two episodes side-by-side! I hope you’re ready! 😉

Save as PDF to iBooks

The Save PDF to iBooks share option in Safari in iOS devices are super awesome! It was unexpectedly good! I use it to save webpages like guides, tutorials, and cheatsheets as PDFs, especially since I’m not online a lot. If you have an iOS device, it’s worth a try. If you don’t have an iOS device, you can use SimplePrint.

TensorFlow Dev Summit 2018

This year’s TensorFlow Dev Summit is awesome as usual! A lot of new tools and updates have been released and I’m so excited to try them out. We’ll look at two of my favorites next but if you want to learn more, here’s a link to the TensorFlow blog.

TensorFlow.js

TensorFlow.js is one of the awesome new members of the TensorFlow family. TensorFlow.js has support for the TensorFlow Layers API, is hardware-accelerated with access to the low-level Ops API (formerly Deeplearn.js), can train models in-browser, and use exported Keras models & TensorFlow SavedModels.

This makes it easier to use machine learning with JavaScript, and this has a lot of implications — because JavaScript can be used almost everywhere: for mobile, desktop, and even VR development. Now we can easily apply Machine Learning to those fields. Also, almost every web developer knows JavaScript, which makes this another step to democratizing AI.

TensorFlow Hub

Similar to how TensorFlow.js can import Keras and TensorFlow models, we can now import powerful machine learning models without breaking a sweat in a single line of code with TensorFlow Hub. TensorFlow hub is like a repository of popular ML models like Inception and the like. Heck, even NASNet is there.

Kubernetes Click

A.K.A “Command Line Interactive Controller for Kubernetes”, Click helps Kubernetes users do their tasks faster by giving context to commands.

Crunch

Crunch is a macOS application that compresses PNGs really well, but is “insanely” slow. You can give it a try if you want extra good compression and you have the time to do it.

PopMotion POSE

PopMotion POSE is the declarative version of PopMotion. Declarative basically means you define what something should do, instead of being concerned with how and when it should happen. This allows you to have the power of PopMotion and giving it simplicity. This makes it really awesome to use with React, which is also declarative in nature.

Jenkins X

Jenkins X brings the power and flexibility of Jenkins for CI/CD and bringing it to Kubernetes. While having a fair level of abstraction, it still hasn’t lost its flexibility, as you still can go deep and tailor everything to your liking.