DEV Community: buphmin

Is ES6 just javascript at this point?

buphmin — Fri, 03 Dec 2021 04:40:07 +0000

So ES6 released in 2015 giving us some amazing features, such as arrow functions, class syntax and let/const. The many useful features in ES6 caused the development community to rapidly adopt ES6 into their toolkit for writing javascript.

What do you all think? Is knowing the ends and outs of ES6 required to claim to "know javascript" in 2021? What about ES7...8? Curious to hear everyone's thoughts on when/how a language advancement becomes a benchmark for proficiency.

What is an Example of a Quality React App?

buphmin — Sat, 09 Oct 2021 21:34:22 +0000

Hey all! Hope you all are having a good day and week!

I am curious if the experienced React developers out there have some open source examples of what they would consider a "quality" React application. More specifically I am looking for examples that are non-trivial (To-Do lists are trivial), and data/business logic driven.

The reason I ask is that I have had a limited exposure to a variety of React applications and React is the most free form of the big three frameworks (Angular, Vue, React). I am optimistic that with your help that some of my existing opinions of React are invalidated by seeing more examples!

When I say quality there are a few things I am looking for. The first is well structured code, something that is coherent and easy to reason about. The second point I am looking for is that the app utilizes reusable components, ones that improve both developer experience and time to develop features. And lastly I am looking for effective use of a state management which clearly connects the data to the view.

What Would Your Perfect Programming Language Look Like?

buphmin — Thu, 14 Nov 2019 05:33:14 +0000

So throughout my career I have learned a number of languages and all have their pros and cons. PHP has some weird choices, Python's OOP seems meh, Go is verbose, and JS can be confusing. This has got me thinking: what features and syntax could I combine to create the "perfect" language for me.

I'll share my thoughts first and I hope to hear from you all on what would be perfect for you!

Starting off I like OOP, so my fictional language would have OOP components. I also like having the flexibility to just write functions. So a mix like Python and PHP. I like static typing and performance, so pre-compiled and optimized it is. I don't write drivers, games, or OSes so I will forgo explicit memory management for convenience at the cost of performance. I like Go's and typescripts type inference so lets keep that, but with the option of explicit declaration. Go's multiple return types is kind of magical, so lets keep that. But let us keep exceptions and try/catch because that cuts down verbosity. Let's also take another page from Go and keep the language fairly simple. It is 2019 so multithreading/coroutines must be easy to use. Oh and JS has these effortless awesome maps called objects, lets keep as much of that as we can with static typing.

So what could my smashed together language look like? Well lets take a peak...

Classes


//hmm interfaces can define properties too like typescript...
//also imports are simple directories relative to the src folder or vendor folder.
//with the exception of the standard library
import AnimalInterface from App/Animals

class Dog implements AnimalInterface
{
  protected sound = "woof!"; //infers string
  public hasFur: boolean;

  //I'm torn as to whether I want the word function, func, fn or nothing...
  public func makeNoise(): void {
    print(this.sound);
  }

  public func getDetails(): (boolean, string) {
    return this.hasFur, this.sound;
  }
}

Looping

numbers = [1, 2, 3, 4];
map = {
 "dog": "bark",
 "cat": "meow"
}; //string => string map

//hmm do i like the map type syntax from go?
anotherMap: map[string]string = {}

for number in numbers {
  print(number);
}

for i = 0; i < 3; i++ {
 number = numbers[i];
 print(number);
}

This is hardly everything in a language, but hey it is a start! Now it is your turn.

Vue Form Builder

buphmin — Sun, 20 Oct 2019 22:04:51 +0000

So I have been looking around for a good vue form builder and I have never really found one that does what I want it to do. Ultimately as a primarily full stack dev I end up having to make both the server side validation and the client side validation. The majority of the time I use client side validation for simple html5 validity checks. Anything more complex then HTML5 checks belong exclusively on the server side, especially since you will need that logic again anyways. What I want in a vue form builder is essentially is to have vue call a formatted API which then vue uses to create the form.

With that being said this is what I am thinking of creating: a set of vue components that each handle rendering a piece of the form, vuex to store the form state in the form of a module, and some helpers to make it easier to work with.

Here is a stubbed outline, excuse the naming and such as this is in pre-prototype phase.


import Vue from 'vue';
import Vuex from 'vuex';
import VueFormBuilderModule from 'vue-builder/Module'; //whatever this is named
import FormBuilder from 'vue-builder/FormBuilder';

Vue.use(vuex);

const store = new Vuex.Store({
  modules: {
    VueFormBuilderModule
  }
});

new Vue({
  store,
  el: "#app",
  async created() {
    try {
      let formData = await fetch("http://apiwebsite/form");
      this.$store.commit("addForm", {
        metadata: formData,
        formName: "myform"
      });
    } catch(e) {
      //catch errors, you know what to do ;)
    }
  }
});

Then in our template:

  <div id="app">
    <form-builder form-name="myform"></form-builder>
  </div>

Form builder then takes the the following example API response:

{
  "first_name": {
    "field_type": "input",
    "data": "John"
    "attributes": {
      "type": "text",
      "maxlength": 50
    }
  }
}

And turns into rendered HTML:

  <form name="myform">
   <input name="first_name" type="text" maxlength="50" value="John" />
  </form>

Of course the input being bound 2 ways with the vuex data. You need more fields then the api would just contain more. If you need to customize rendering then you would use the provided slots.

This way you can keep all the logic of building and validating your forms in one spot.

Let me know what you all think of this idea! Would it be something you would use presuming it was flexible enough? Of course this is intended to be a public repo and FOSS.

Exploring Google Cloud Platform

buphmin — Wed, 14 Aug 2019 04:12:49 +0000

Disclaimer: This really isn't a tutorial, more of just some things I did and my thoughts.

So here I am going to go through my learning and usage of the Google Cloud Platform, or GCP for short. This article roughly summarizes what I did to create a docker based web server with a database on GCP.

Background

So awhile back I built a fantasy football draft board website for fun. I built it with PHP using the Symfony framework and Aurelia. Hosting was done on 1&1 and over all I was not satisfied. Performance was meh, php and websockets are not great and I had very little control over the server. The next year I went ahead and rewrote the whole thing. This time I used node and Adonis and Vue on the front with hosting on AWS. Performance skyrocketed with almost all API calls returning under 100ms the sweet spot and I had web sockets for live notifications. AWS worked well but ended up being quite expensive (relative) after the trial for a website sitting there with no traffic. So now I am trying out GCP to see how I like it.

Getting Started

The first step was of course setting up an account with GCP. This was as easy as can be since it just links to your Google account.

Next was launching a VM. For my use I will just be using docker to run the website since docker makes it easy to manage dev/test/prod server configuration and local dev. Looking through the product list it was obvious to me that compute engine is what I needed.

Making a VM

Once you get your account you can go into the GCP console and from there getting to the compute engine is easy. Creating a vm is simple, you pick where you want it and how beefy to make it. For me I am just playing around, so a micro instance was sufficient. Now since I plan to only run things on the server from docker I went ahead and chose the "container optimized OS" more on that later.

Container Registry

Since I am using docker and containers I wanted a private secure place to store my images. Fortunately GCP makes it easy to create your own registry and push/pull from it. Simply follow the docs.

Networking

Getting to the correct networking product took a little more effort but I eventually found that the VPC was what I needed. Using the VPC in hind sight is quite easy, but I had a lot of issues due to the VM image I selected. What I wanted was to block all connections that were not from me. Creating a firewall rule with my ip as a filter works great.

Trouble in Paradise

I still do not know exactly what was wrong but selecting that container optimized os (chromium os) caused me all sorts of issues. Basically I ssh-ed into the server, ran docker pull on my image, and then docker run --network host and no matter what I could not get access to the website. I thought maybe something was up with docker so I even loaded a Go binary bare bones "hello world" website. Running the binary resulted in "permission denied". I then gave said executable 777 permissions as a sanity check (intending to revert), but still "permission denied." Sudo run, but still permission denied. At that point I abandoned the VM and created a new one with a minimal ubuntu and installed docker. Everything worked fine from there. ¯_(ツ)_/¯

Creating a MySQL Instance

GCP has several varieties of databases and database services. After some research their cloud SQL product is what I needed. It allows you to make a MySQL or Postgres database. The process to create it was simple and similar to creating a compute engine VM. One thing I liked was that it can load and run a SQL file stored on the platform. Following the docs/tooltips/help links I uploaded a small script to create my tables and foo data. Worked like a charm.

Linking the web VM to the MySQL instance was quite easy with a quick edit I was able to limit access to who could get to the server.

Comparison to AWS

So lets see how GCP compares to AWS.

Pros

Clearer docs
Easier setup overall

Cons

AWS was a little easier to debug problems
AWS performance seems a little higher in response time (tentative)

Ultimately the setup between both of them is pretty similar and due to that GCP could seem easier because I already have used a similar product.

Conclusion

I like GCP so far. Everything was pretty easy to use and setup, with the exception of that strange VM image which still confuses me. The docs were informative and were genuinely helpful. I will have to use it more in order to give a better assessment over all but so far it has my thumbs up.

Are There Good Recruiters?

buphmin — Tue, 30 Jul 2019 03:54:34 +0000

So I always hear people make fun of recruiters (myself included), or talk about awful experiences with them but I never really hear anyone say anything good.

I'm interested to hear if anyone has ever had a good experience with recruiters and would care to share. Maybe some tips on how to spot good recruiters. I think that could help many people in the future.

Framework Impressions: A Brief Look Into Lumen

buphmin — Sun, 12 May 2019 01:28:16 +0000

So it has taken me some time to think about the next part of this series and how deep I really want to dive into each framework. For this article and the rest I end up making in the series I will do more of a first impression, rather than a deep dive. This should mimic more of a prototyping session than full feature review. Ultimately using a framework (or not) is matter of preference and my role with these articles should be to note the following points:

Are the docs clear and easy to follow
How versatile is the framework
A quick glance at performance

With that out of the way lets take a look at Lumen. Lumen is a micro-framework based off Laravel which by extension is partially based on Symfony components. In my quick impression of Lumen I would say usage is relatively straight forward, especially after using AdonisJS, which is modeled after Laravel.

Documentation

The docs is the first part that struck me as a bit odd and hard to follow regarding Lumen. The docs have a bad habit of basically saying "it's not documented here, go look at the Laravel docs." This could be fine, but some of the context and usage is different in Lumen than in Laravel so sometimes you have to piece it together yourself. This was immediately apparent when I simply just wanted to do a raw sql query. The docs say

$results = app('db')->select("SELECT * FROM users");

but it was unclear to me that 'app' is a global function.

Versatility

Due to the way Lumen is structured you have mostly free reign over what you want to do. Besides a few things you can mostly use raw PHP based off everything I have seen. Creating services is fairly straightforward and you can rely on the dependency injection engine to managed dependencies for you. I did not toy around with ORMs since this is a micro-framework, but there is the option to use them if you want. It looks like Eloquent, the Laravel ORM, is readily available if you want. Overall I don't think there is much you couldn't due with Lumen as long as it is supported by the PHP platform.

Setting up a route was fairly trivial. You can define the route in web.php with a callback or a string reference to a class function.


$router->get('league_players/raw/{id}', function($id) {
    $sql = "
            select * from 
            league_player lp
            join league l on lp.league_id = l.id
            join player p on lp.player_id = p.id
            where lp.id = :id
        ";

   return app('db')->select($sql, ['id' => $id]);
});

$router->get('league_players/service/{id}', 'LeaguePlayerController@getLeaguePlayer');

Dependency Injection

Lumen does have dependency injection available and I was able to create a route using a class controller and injecting a service to the class route. I did not notice a significant overhead using the class method and DI.

Performance

So I am going to change up my performance testing from now on. Since I do not have a separate machine to run testing on I will just give my two cents and a repo you can use to do your own testing.

Running through a few scenarios I found Lumen to be close to but faster then Symfony 4. Under single requests there was no difference. At a 100+ concurrent requests you do notice Lumen pulling ahead.

Final Thoughts

Overall I am not super impressed with Lumen. In today's world where expressjs is commonplace I feel like the need for Lumen is not really there. The docs are adequate but not superb and performance (stock at least) is not good enough vs Symfony to really consider using it over Symfony.

I would say you are better off using a full featured PHP framework, or picking up express (and learning node.js) if you want a straightforward microframework with high performance. Another option would be to create your own with some simple setup if you really want to stick to php.

Well that about wraps up my impressions of Lumen. Let me know your thoughts in the comments.

What framework/microframework should I look at next? I'm thinking something in js/go, let me know!

EDIT:

I forgot to link the repo so you can play around with what I did! https://github.com/buphmin/LumenComparison

Some Observations While Learning Golang

buphmin — Sun, 03 Feb 2019 18:42:05 +0000

So I have been doing a bit of coding in golang recently and I figured I would share some of my observations.

The Standard Library is Very Robust

I have found so far that everything I have needed to do so far can be done at least pretty well with the standard library. That is not to say it is perfect, but there has been nothing that I could not do. Need to call an API? Just import net/http. Want to convert something to json? Just import encoding/json. Go's standard library has you covered for all of your basic needs including: IO, file system, encryption, etc. So far the only thing I haven't really been a fan of is the standard logger. For that I replaced it with zap logger.

Go's Dependency Management Could Be Better

So far I have exclusively made use of go modules as a feature in Go 1.11 which released in August of 2018. This allows each project to live in a separate directory anywhere in the file system and have version controlled dependencies. From my understanding this is the first official way of having project specific dependencies. So far though I have found some things just do not work using go modules. For instance I was unable to use Revel using go modules, which I had planned to explore as the 2nd entry in my framework impressions series. Compared to npm and composer, the two package managers I am familiar with, Go needs some time to get everything standardized and to get all of the libraries on board.

Go Is Versatile

Specifically there are three unique features of go which offer the developer a ton of flexibility: methods on any data type, multiple return values for functions, and interfaces.

Methods on Any Data Type

So in go any data type can have methods. For instance lets say I want a int that can double itself.

type Doubler int

func (d *Doubler) Double() {
    (*d) = (*d)*2
}

func main() {
    var num Doubler
    num = 3
    num.Double()
    fmt.Println(num) //prints 6!
}

This can be pretty handy, though be careful not to abuse it. I can easily see this feature abused into some strange spaghetti.

Multiple Return Values

So in go functions can return multiple values of any variance of data type. This allows for some very nice possibilities that require workarounds to achieve in other languages. For instance say you want to compare two people to check if they are the same:

type Person struct {
    Name string
    Age int
}

//isSamePerson takes two Person structs and returns whether they are equal
//It also returns a list of differences
func isSamePerson(firstPerson Person, secondPerson Person) (bool, []string) {
    differences := []string{}
    isSame := true

    if firstPerson.Name!= secondPerson.Name{
        differences = append(differences, "Names do not match")
        isSame = false
    }

    if firstPerson.Age != secondPerson.Age {
        differences = append(differences, "Ages do not match")
        isSame = false
    }

    return isSame, differences
}

Here we have a function that checks if two people are the same, and we can get the boolean value that we need, but we also can see what is different.

Interfaces

Interfaces in Go work quite a bit different than other languages. Interfaces represent a sort of contract between two parts of your code defining the behavior of functions. In most object oriented languages an interface is an explicit declaration on a class stating that it must have said functions with the defined requirements in an interface. Go takes a different approach with its interfaces by making them implicitly defined. Any data type that has methods matching the signature of the interface is acceptable to use. This is good and bad in my opinion. Combined with Golang's capability of having methods on any data type this allows for very flexible usage. This means any data type can satisfy the interface if the methods match. Additionally a data type can potentially satisfy multiple interfaces without conflict. I have found while coding is that it is harder to make sure you are implementing an interface. This is largely due to the implicit nature of Go's interfaces. Example time!

type Doubleable interface {
    Double()
}

type DoubleInt int 

func (d *DoubleInt) Double() {
    (*d) = (*d) * 2
}

type DoublePeople struct {
    NumPeople int
}

func (d *DoublePeople ) Double() {
    d.NumPeople *= 2
}

func main() {
    var numInt DoubleInt = 1
    people:= DoublePeople{NumPeople: 4}

    doDouble(&numInt)
    doDouble(&people)
    fmt.Println(numInt)//prints 2
    fmt.Println(people.NumPeople)//prints 8
}


//doDouble takes a doubler and doubles it
func doDouble(doubler Doubleable)  {
    doubler.Double()
}

Both an int type and a struct type can both be doubled and can both be passed to the doDouble function since they both implicitly satisfy the Doubleable interface.

Go Has Some Nice Tooling

Unlike other languages I have worked with Go has some nice built in tools. Unit testing, benchmarking, and profiling are all included without needing to install any 3rd party utilities. Additionally debugging also works from the start. This means getting started to writing go code is quite straight forward, at least when using go modules. Go vet can check your code for common problems and go fmt formats your code to the Go standard. Overall compared to PHP and JS at least I needed to install far less things just to get started with writing and testing code. This doesn't mean all of the tools are perfect for everyone, for instance you may want to extend the testing suite with an assertion library or a BDD framework. Regardless Go gives you the tools you need to write good well tested code.

Go is a neat language and so far I have found it to be a pretty simple language to use. There is very little syntax, and a fairly small amount of concepts you need to know to be effective.

What I learned In 2018!

buphmin — Sun, 06 Jan 2019 18:34:58 +0000

We developers have a tendency of telling ourselves that we aren't good enough and have been too lazy because we didn't learn everything. For me I certainly felt like I learned almost nothing this year until I broke it down and analyzed my year logically. I took a look at all the things I learned in between my normal work, and life schedule and compiled a list.

Without further ado here are the things I learned:

Webpack

I may have caught on late but I dedicated some time to learn webpack and got it implemented at my work and personal projects. I love the bundling and the ability to write js code as modules. Additionally being able to use typescript and vue together has been a great boon.

What I Can Improve

One thing I have not been able to find is why webpack adds so much extra code as part of the bundling process. It is not terribly significant in most of the work I do because we have an internal app at LAN speed, but for a live website that can be significant.

Typescript

Typescript is great. Slowly we have been transitioning older code to use typescript and it has been a boon. Refactoring code becomes much easier, and understanding the flow of larger programs becomes easier.

What Can Get Better

Generics can be tricky sometimes and there are a few things that can take me some time to figure out (I'm looking at you bluebird promises + async/await).

Golang

I took the opportunity at work to learn golang for a project that could be sped up considerably with threading. I found Go to be very intuitive and easy to learn. I can certainly see why some choose to move to Go for high performance needs.

Things To Improve

I'm still not quite fluent so I need some more practice before I feel like I can tackle anything. The other thing is I really focused on go modules in 1.11 so my understanding of the classic Go dev methodology could use some work.

Some Other Things That I Will List

Lets see what else I can remember...

Node.js for webdev (used before in a kafka event system)
Adonis framework
Improved JS/PHP fundamentals
Some basics of C++

What To Do In 2019?

I am not much of a new year's resolution person, but I do have a few ideas on what I want to learn in 2019.

Golang api webdev
Vue server side rendering
Progressive Web Apps

All right folks, that's it for this post. Hopefully I have inspired you to take a look at your own work over the year and give yourself a pat on the back for all that you accomplished!

Are Side Projects THAT Important?

buphmin — Wed, 12 Dec 2018 04:12:34 +0000

So I have been trying to force myself to start a new side project recently and it has got me thinking how important it really is to have side projects. I believe learning is important and to keep on top of technology but do you really need a bunch of side projects to do that?

I have had exactly one major side project to build a fantasy football draft board. I first built it in Symfony and Aurelia, but I was not pleased with the result so I rebuilt it with Adonis and Vue for backend and frontend respectively. I learned a lot in the process about building API driven single page apps.

On the other hand I also learn a ton by fiddling with things at work in between projects and by reading articles such as on DEV.

So I wanted to see what the good people of DEV think about side projects and how necessary they are. I for one think that they are nice to have, but not at the expense of your happiness and well being.

Framework Impressions: A Brief Look Into Symfony 4

buphmin — Sun, 18 Nov 2018 21:23:02 +0000

Edit:

I went ahead and ran some performance tests again with optimizations with better results.

Preface

This is the first post in a series of articles I plan to write where I will be looking at a variety of server side web frameworks or using no framework in several languages.

Goals

My primary goal is to highlight a few server side frameworks and to give enough information so that you, the reader, can make a judgement as to whether or not you should do more investigation for your use case.

Here are some goals:

Test flexibility
- Does it impede dev?
SQL compatibility
- Can you use raw sql
- Is the ORM, if present, good for almost any type of query?
Quick response time performance for a multi join api endpoint
- How many concurrent users can the framework support before response time is too high for good UX.

Setup

I have done everything in docker to make it easy to keep things separated. For load testing I will be using k6.

Repo: https://github.com/buphmin/symfony4-impressions
Load tester:

docker pull loadimpact/k6

As a reference for the performance portion here is how I am testing

Hardware/Hardware Config

My hardware is faster than the majority of people so your mileage may vary on the benchmarks. I am also running everything within a linux mint 19 VM. Specs are as reserved by the VM.

i7 8700k running at 4.9ghz 6 cores
8GB ram running at 3600mhz

Cores 0-1 reserved for the web server
Cores 2-3 reserved for the database
Cores 4-5 reserved for k6

Impressions

So as a disclaimer I have worked with Symfony for many years, so this is hardly a first impression for me. I do feel, however, that I can objectively qualify Symfony's strengths and weaknesses in a way that you can determine whether or not it warrants your attention. You should always judge a technology for yourself and not blindly think it is good just because (insert famous person here) said so.

What is Symfony

Symfony is a full featured full stack framework designed to give you an all in one solution for web development. Symfony attempts to be a one size fits all type of framework with built in authentication, server side rendering/templating, api support, etc.

Flexibility

In terms of flexibility Symfony is quite flexible, especially for a fully featured framework. That does not mean Symfony is perfect though. You have to live with the config files that Symfony requires and set them up in the Symfony way. Additionally by default Symfony expects you to put your files in specific locations forcing you to

Symfony allows you to override many of it's conventions but you will likely find troublesome. For instance you can override the directory structure, but then likely be confused when the docs assume you are using the defaults.

For SQL Symfony ships with Doctrine for use of both the ORM and DBAL (DataBase Abstraction Layer). Both can be used exclusively or simultaneously. The doctrine ORM is pretty good and will allow you to use most database structures. A notable weakness is composite foreign key relations as primary keys which either cannot be done or will take some creativity to work around. The doctrine mapping can take some time to setup but Symfony comes with some tools to make the process simpler if you have already structured your database. On the flip side you can use the Doctrine DBAL for raw SQL. The DBAL is just a light wrapper around PDO, PHP's native database connection library that provides some convenience methods. Symfony also has the ability to use other connection interfaces, such as to connect to MongoDB, but the Symfony docs shy away from that and I will not cover it here. Between the the ORM and DBAL you have ways to work with a SQL database however you need.

Here are some examples of raw SQL vs ORM endpoints with multi join:

    /**
     * @param integer $id
     * @param Connection $conn
     * @return JsonResponse
     * @Route(path="/league_players/raw/{id}", name="league_player_raw")
     */
    public function getLeaguePlayerRawAction($id, Connection $conn)
    {
        $sql = "
            select * from 
            league_player lp
            join league l on lp.league_id = l.id
            join player p on lp.player_id = p.id
            where lp.id = :id
        ";

        $leaguePlayers = $conn->fetchAll($sql, [
            'id' => $id
        ]);

        if (count($leaguePlayers) === 0) {
            throw new NotFoundHttpException('Player not found');
        }

        return new JsonResponse($leaguePlayers[0]);
    }

    /**
     * @param LeaguePlayer $leaguePlayer
     * @param SerializerInterface $serializer
     * @return Response
     * @Route(path="/league_players/{leaguePlayer}", name="league_player")
     */
    public function getLeaguePlayerAction(LeaguePlayer $leaguePlayer, SerializerInterface $serializer)
    {
        $data = $serializer->serialize($leaguePlayer, 'json');
        return new Response($data);
    }

To end the flexibility section it is interesting to note that the Symfony framework is build from a motley of independent reusable components. Each of these can be used outside of the Symfony framework as a whole. For instance if you just need a router utility then you can use the Symfony routing component and manage the rest of the stack yourself.

Performance

I will be judging the two endpoints above to judge the raw SQL implementation and the ORM implementation. The ORM implementation is slightly different, but is a realistic implementation of what you might do with an ORM endpoint.

1 Concurrent User

Raw:

docker run --network host --cpuset-cpus "4-5" -v $PWD/loadTests:/src -i loadimpact/k6 run --vus 1 --duration 10s /src/getLeaguePlayerRaw.js

Result:

http_req_duration..........: avg=4.51ms  min=3.51ms  med=4.46ms  max=5.76ms   p(90)=5.09ms  p(95)=5.42ms

Pretty good performance, 11.73ms duration. Obviously since this is local to local this is not exactly "real" world performance but it gives us a rough idea.

ORM:

docker run --network host --cpuset-cpus "4-5" -v $PWD/loadTests:/src -i loadimpact/k6 run --vus 1 --duration 10s /src/getLeaguePlayer.js

Result:

http_req_duration..........: avg=16.74ms min=15.06ms med=15.98ms max=21.15ms  p(90)=19.43ms p(95)=20.29ms

The ORM implementation is close to double the request time in this scenario.

10 Concurrent Users

Change --vus to 10

Raw:

 http_req_duration..........: avg=8.81ms  min=3.24ms med=8.35ms max=19.11ms  p(90)=12.5ms  p(95)=17.18ms

ORM:

http_req_duration..........: avg=51.44ms min=14.81ms med=51.05ms max=82.89ms  p(90)=76.4ms  p(95)=80.5ms

The extra load of the ORM method is becoming evident.

50 Concurrent Users

Change --vus to 50

Raw:

http_req_duration..........: avg=34.75ms  min=4.57ms med=31.57ms max=90.81ms  p(90)=58.4ms  p(95)=76.5ms

ORM:

http_req_duration..........: avg=201.94ms min=15ms    med=216.65ms max=1.69s    p(90)=334.99ms p(95)=369.24ms

Edit:

Performance is pretty good with raw SQL in my tests at 50 concurrent users. I will note that I saw a very wide variation between runs. Most runs were between 28-45ms but some shot to 400ms, which could just be the limitations of my testing environment. With the implemented optimizations performance I was able to get around 130ms response time at 200 concurrent users. This is good but still trails behind anything in node.js as we will see in future articles ;)

Here we are at the limit of what 2 cores can achieve. 500ms is too much for good UX in most circumstances. We find that the ORM adds extra overhead over the raw SQL implementation which is to be expected.

Results

My impression of Symfony is that it quite flexible and gives you a lot of ways to go about your business.

Pros

flexibility
good docs
mostly stays out of your way

Cons

some limitations with the ORM
high concurrent user performance is not great

Recommendation:

I would say Symfony is worth taking a look at for most people who are interested in a framework. It offers good flexibility and pretty good low load performance which makes it ideal for an internal company app.

Let me know if you have any insights or questions as this will be my first fairly in depth article.

How to Stay Productive at Work During Slow Periods

buphmin — Thu, 04 Oct 2018 03:43:33 +0000

Here I will be covering some ideas on how to be productive at work when you have no assigned tasks, or when you are waiting to be able to work on something.

I currently work for a marketing intelligence company, where we take tons of data, analyze it, and use it to find the best audience to market to. The nature of our company means that we get very busy for the holiday marketing push and then slow down after the holidays are over. Due to this our main development pushes are early in the year with a slowdown towards the end of the year. This leaves plenty of time to work on something like learning or refactoring some old code.

I will split this into three categories of work to be done: new code, refactoring, learning.

For new code I am primary talking about new libraries to help clean up development or make the development process easier down the road. Anyone who has worked in dev for awhile can testify that sometimes we are moving to quickly to write a reusable library for something, or perhaps we think we will only use a piece of code in this one spot. Look at and pick some repetitive code that would be useful to have in a centralized utility and have at it. Another option for new code is to look at new technology and see if it is useful for your situation. For me typescript was a perfect contender for our complex javascript.

The second option is refactoring existing code. Maybe you wrote the code years ago or someone else did, but either way every time you have to interact with it you groan (to yourself or out loud). This is a perfect contender of something that can be refactored. Use some prudence when choosing what to refactor based of your time and the impact it will have.

Lastly you can use your free time to learn something new. Maybe it's a new language, some new techniques, or the latest features in your language(s) of choice. As a developer we always need to be expanding our knowledge and capabilities and taking some time to learn will be a benefit to you and your company.

So the next time you feel like you do not have anything to work on and are tempted to go to facebook, reddit, or similar (dev.to is ok ;P) consider one of the options above.