DEV Community: Richard Lenkovits

Simple bash loading animation

Richard Lenkovits — Thu, 27 Jul 2023 09:44:53 +0000

I was looking for a simple way to achieve a basic load icon that ticks after a piece of text in bash, but there was noting I could just easily copy paste. Now I'll provide one for you, no shenanigans, no messing around.

Short story

I've found this one, Silejonu's solution on Github but this is rather a module than something you can copy paste, and sometimes you don't want to add whole dependencies, just a piece of logic.

So here it is:



function loading_icon() {

    local load_interval="${1}"

    local loading_message="${2}"

    local elapsed=0

    local loading_animation=( '—' "\" '|' '/' )

<span class="nb">echo</span> <span class="nt">-n</span> <span class="s2">"</span><span class="k">${</span><span class="nv">loading_message</span><span class="k">}</span><span class="s2"> "</span>

<span class="c"># This part is to make the cursor not blink</span>
<span class="c"># on top of the animation while it lasts</span>
tput civis
<span class="nb">trap</span> <span class="s2">"tput cnorm"</span> EXIT
<span class="k">while</span> <span class="o">[</span> <span class="s2">"</span><span class="k">${</span><span class="nv">load_interval</span><span class="k">}</span><span class="s2">"</span> <span class="nt">-ne</span> <span class="s2">"</span><span class="k">${</span><span class="nv">elapsed</span><span class="k">}</span><span class="s2">"</span> <span class="o">]</span><span class="p">;</span> <span class="k">do
    for </span>frame <span class="k">in</span> <span class="s2">"</span><span class="k">${</span><span class="nv">loading_animation</span><span class="p">[@]</span><span class="k">}</span><span class="s2">"</span> <span class="p">;</span> <span class="k">do
        </span><span class="nb">printf</span> <span class="s2">"%s</span><span class="se">\b</span><span class="s2">"</span> <span class="s2">"</span><span class="k">${</span><span class="nv">frame</span><span class="k">}</span><span class="s2">"</span>
        <span class="nb">sleep </span>0.25
    <span class="k">done
    </span><span class="nv">elapsed</span><span class="o">=</span><span class="k">$((</span> elapsed <span class="o">+</span> <span class="m">1</span> <span class="k">))</span>
<span class="k">done
</span><span class="nb">printf</span> <span class="s2">" </span><span class="se">\b\n</span><span class="s2">"</span>



}

loading_icon 60 "I'm loading!"

And here's what it looks like:

Limitations

Shows a given loading_message and after it a small loading icon for the provided load_interval seconds.
After the provided time elapsed the last character of the loading icon is erased and a new line is started (this can be changed by updating printf " \b\n").

You can get more animation ideas from Silejonu, bash_loading_animations file, all you have to do is to replace the loading_animation variable in the script (don't forget to remove the first element, the interval number).

Enjoy! ^^

Why common CI ownership is a myth at large companies

Richard Lenkovits — Wed, 07 Jun 2023 13:44:59 +0000

People need to keep their environment and infrastructure in shape in order to be productive. You might be a farmer who primarily grows corn, but you also must build a pavement between your house and your farm so you can get to work, and mow the lawn next to it so it doesn't grow over. You have to change your lightbulbs if they go out so you find your way home, and maybe take out the trash every once in a while.

The situation is similar though a tad bit more complicated for smaller communities — like a group of neighbors on a spot of land, or for the inhabitants of a smaller residential building. Somebody has to mop the floors once in a while, clean the common areas and fix busted fittings.

The issues come when we scale things up beyond that — see something like a small village, or a city. In a residential building it's easy to see why it's everybody's problem that the elevator stopped working. In a village however you may find it hard to justify why you should care, that a bench broke at the bus stop when you're only using the train. The village has a lot of people, it's easy for you to hide and shake the responsibility, which you can easily do without caring — until a later time the bench brakes at the train station.

At a small software company when the build breaks, or the servers go down you won't just lean back in your chair saying it's not your problem. Come on, there are like three developers, one of those is on holiday. That leaves the two of you, both of your work being blocked. A small company is like a residential building.

A large company is however more like a country. In a country when you notice a busted street lamp you won't start fixing it. That's why you pay tax and have specialized teams to deal with these issues.
When an ansible playbook that should configure a VM fails somewhere in an automated setup script for tests you cannot just expect a guy from backend development to start fixing it, when he's busy to deliver for a deadline.

I saw companies trying to find ways to have developers acquire a "CI (or) DevOps mindset" so that they keep track of the whole verification chain, develop it, and also keep track of their changes through the highly complex pipelines and fix it if needed. On top of this, integration and verification pipelines become their own product at large companies due to multi-layered release bureaucracy and the highly complex nature of the products that are being developed.

I know that it sounds tempting to imagine that your developers will reach targets effectively and also develop and maintain your verification pipelines at the same time but it's a wild-goose chase.
You simply cannot spare specialized DevOps teams. Unless you're fine with your citizens fixing street lamps for themselves with however dingy ways they can manage.

Test Ansible playbooks using Docker

Richard Lenkovits — Tue, 21 Mar 2023 21:28:17 +0000

Okay so this is what we're going to do:

Setting up an ssh accessible Ubuntu container.
Running an Ansible playbook against it to test that playbook.

Come again?

I know it's weird, hear me out.

Here's the scenario that we're trying to tackle. Imagine that:
1. You have Ansible playbooks to configure certain machines.
2. You run these playbooks once during the initial setup and forget about them.
3. A lot of time passes.
4. Later a developer needs to add a package or some change to the given host or host group.
5. They should update the ansible playbook and run it, but they're afraid they'll break the environment. Who knows when were those playbooks last run? Maybe they even have an invalid description of the current system. As a result the developer either: A.: Just does the changes by hand and best case, B.: ...updates the playbooks as well. But who know if it's a correct update.

This is how playbooks decay - at least in our environments.

Why such a basic validity check could be of good use

Having some simple tests could solve our issues, and provide some constant feedback about the playbooks' validity. But how do you test Ansible playbooks (other than lint them)? Playbooks are just ordered instructions describing a desired state.

Still, they could be faulty - it's easy to make mistakes when you're trying to translate your desired configuration steps into Ansible tasks. You may mess up a task, forget a necessary parameter on a module, maybe you try to install something for which you forget to provide it's prerequisites.

Preferably we want some tests which can run our playbooks against an ephemeral environment to see if they're -well- runnable. This is where docker comes into the picture. In docker you can test most of the things that you'd want to do with Ansible. Obviously for more complicated playbooks this might not be a good solution.

Test setup

This is how our small demo directory -with which we'll make our point- looks like:

.
├── Dockerfile
├── ansible.cfg
├── machine-setup.yml
└── setup-container.sh

1. Example Playbook and config

There's a very simple playbook machine-setup.yml, that sets up some packages on the host group called target_group.

---
# yamllint disable rule:line-length
- name: Setup Machine
  hosts: target_group
  gather_facts: false
  become: true

  tasks:
    - name: Install requirements
      apt:
        update_cache: true
        pkg:
          - python3
          - flake8
          - pylint
          - python3-pip
        state: latest
      register: task_result
      until: not task_result.failed
      retries: 1

We provide some necessary Ansible config in a cfg file ansible.cfg:

[defaults]
# Avoid host key checking - to to run without interaction.
host_key_checking = False

2. Test Container

We create a Dockerfile too which describes for us an ssh accessible ubuntu container.

FROM ubuntu:latest

ARG USER=${USER}

# Add sudo and openssh-server
ENV DEBIAN_FRONTEND=noninteractive
RUN apt update && apt install openssh-server sudo -y

# Setup running user on the container with sudo rights and
# password-less ssh login
RUN useradd -m ${USER}
RUN adduser ${USER} sudo
RUN echo "${USER} ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/sudoers

# As the user setup the ssh identity using the key in the tmp folder
USER "${USER}"
RUN mkdir ~/.ssh
RUN chmod -R 700 ~/.ssh
COPY --chown=${USER}:sudo id_rsa.pub /home/${USER}/.ssh/id_rsa.pub
RUN cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
RUN chmod 644 ~/.ssh/id_rsa.pub
RUN chmod 644 ~/.ssh/authorized_keys

# start ssh with port exposed
USER root
RUN service ssh start

EXPOSE 22

CMD ["/usr/sbin/sshd", "-D"]

3. Testing Script

Our script will start this container, run the playbook against it and clean up everything. Let's see it step by step.

We make sure to have a unique container name, and a path to our assets.

identifier="$(< /dev/urandom tr -dc 'a-z0-9' | fold -w 5 | head -n 1)" ||:
NAME="compute-node-sim-${identifier}"
base_dir="$(dirname "$(readlink -f "$0")")"

We add a function to create temporary directory to store our temporary assets (like the inventory and the ssh id).

function setup_tempdir() {
    TEMP_DIR=$(mktemp --directory "/tmp/${NAME}".XXXXXXXX)
    export TEMP_DIR
}

We setup a cleanup function which will be able to clean up the temporary folder and the container as well.

function cleanup() {
    container_id=$(docker inspect --format="{{.Id}}" "${NAME}" ||:)
    if [[ -n "${container_id}" ]]; then
        echo "Cleaning up container ${NAME}"
        docker rm --force "${container_id}"
    fi
    if [[ -n "${TEMP_DIR:-}" && -d "${TEMP_DIR:-}" ]]; then
        echo "Cleaning up tepdir ${TEMP_DIR}"
        rm -rf "${TEMP_DIR}"
    fi
}

We need a function that will create ssh identities so Ansible can access the container through ssh. During docker build these will be added inside the container by a COPY step (see above in the Dockerfile).

function create_temporary_ssh_id() {
    ssh-keygen -b 2048 -t rsa -C "${USER}@email.com" -f "${TEMP_DIR}/id_rsa" -N ""
    chmod 600 "${TEMP_DIR}/id_rsa"
    chmod 644 "${TEMP_DIR}/id_rsa.pub"
}

We build and start the container with this function - providing the TEMP_DIR as it's context. We figure out the container's address for ssh.

function start_container() {
    docker build --tag "compute-node-sim" \
        --build-arg USER \
        --file "${base_dir}/Dockerfile" \
        "${TEMP_DIR}"
    docker run -d -P --name "${NAME}" "compute-node-sim"
    CONTAINER_ADDR=$(docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "${NAME}")
    export CONTAINER_ADDR
}

We create a test inventory which has our target_group containing only the container by it's address we fetched above. We also add the ssh identity to be used when running the playbook.

function setup_test_inventory() {
    TEMP_INVENTORY_FILE="${TEMP_DIR}/hosts"

    cat > "${TEMP_INVENTORY_FILE}" << EOL
[target_group]
${CONTAINER_ADDR}:22
[target_group:vars]
ansible_ssh_private_key_file=${TEMP_DIR}/id_rsa
EOL
    export TEMP_INVENTORY_FILE
}

We add the playbook runner function. It will run against our temporary inventory.

function run_ansible_playbook() {
    ANSIBLE_CONFIG="${base_dir}/ansible.cfg"
    ansible-playbook -i "${TEMP_INVENTORY_FILE}" -vvv "${base_dir}/machine-setup.yml"
}

Now we run it all:

setup_tempdir
trap cleanup EXIT
trap cleanup ERR
create_temporary_ssh_id
start_container
setup_test_inventory
run_ansible_playbook

Full script for reference:

#!/usr/bin/env bash

set -euo pipefail

identifier="$(< /dev/urandom tr -dc 'a-z0-9' | fold -w 5 | head -n 1)" ||:
NAME="compute-node-sim-${identifier}"
base_dir="$(dirname "$(readlink -f "$0")")"

function cleanup() {
    container_id=$(docker inspect --format="{{.Id}}" "${NAME}" ||:)
    if [[ -n "${container_id}" ]]; then
        echo "Cleaning up container ${NAME}"
        docker rm --force "${container_id}"
    fi
    if [[ -n "${TEMP_DIR:-}" && -d "${TEMP_DIR:-}" ]]; then
        echo "Cleaning up tepdir ${TEMP_DIR}"
        rm -rf "${TEMP_DIR}"
    fi
}

function setup_tempdir() {
    TEMP_DIR=$(mktemp --directory "/tmp/${NAME}".XXXXXXXX)
    export TEMP_DIR
}

function create_temporary_ssh_id() {
    ssh-keygen -b 2048 -t rsa -C "${USER}@email.com" -f "${TEMP_DIR}/id_rsa" -N ""
    chmod 600 "${TEMP_DIR}/id_rsa"
    chmod 644 "${TEMP_DIR}/id_rsa.pub"
}

function start_container() {
    docker build --tag "compute-node-sim" \
        --build-arg USER \
        --file "${base_dir}/Dockerfile" \
        "${TEMP_DIR}"
    docker run -d -P --name "${NAME}" "compute-node-sim"
    CONTAINER_ADDR=$(docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "${NAME}")
    export CONTAINER_ADDR
}

function setup_test_inventory() {
    TEMP_INVENTORY_FILE="${TEMP_DIR}/hosts"

    cat > "${TEMP_INVENTORY_FILE}" << EOL
[target_group]
${CONTAINER_ADDR}:22
[target_group:vars]
ansible_ssh_private_key_file=${TEMP_DIR}/id_rsa
EOL
    export TEMP_INVENTORY_FILE
}

function run_ansible_playbook() {
    ANSIBLE_CONFIG="${base_dir}/ansible.cfg"
    ansible-playbook -i "${TEMP_INVENTORY_FILE}" -vvv "${base_dir}/machine-setup.yml"
}

setup_tempdir
trap cleanup EXIT
trap cleanup ERR
create_temporary_ssh_id
start_container
setup_test_inventory
run_ansible_playbook

Hope you found something useful here!

How to upgrade your PC's RAM

Richard Lenkovits — Wed, 30 Mar 2022 15:16:49 +0000

Short preface, no BS

Howdy!
You probably ended up here because you ~~like to have 50 chrome tabs open~~ need to upgrade your PC's RAM and you want to do it right. I just upgraded RAM in my PC so let me spare you all the time I spent to figure out all the technical stuff.

In this article we will:

1. See how to get the memory specs of your system.
2. How to use those specs to select RAM suitable for upgrade.

Let's go!

What factors do I have to consider?

In order to make sure the RAM you buy will work, you'll have to consider the following factors:

RAM capacity of your motherboard?
Form factor, type, speeds, and voltages supported by your motherboard?
Compatibility with your current RAM? (Type, speed, voltage and CL)
And finally how much RAM do you actually need?

Let's see how to figure out all these specs and select RAM with the correct parameters!

Assembling a new PC?

Normally with a few commands you can figure out your memory specs. However if you're just assembling your PC you obviously won't be able to run commands. This case, you can go to the site of your motherboard's manufacturer and see what it supports.

Here's an example of an MSI Motherboard's details. In the DDR4 MEMORY row you can see all the frequencies supported by the manufacturer.

Anyhow, let's get this done bois' and girls!

Get RAM specs for Windows:

Start a Command Prompt, make sure you run as administrator, then execute the following commands:

Get memory details with the wmic memorychip command. This will print parameters separately for each RAM module installed - so the number of printed lines will tell you how many RAM modules you have installed. ```

wmic memorychip get memorytype, capacity, speed, formfactor, manufacturer, configuredvoltage

- Then **get the total number of memory slots** with the `wmic memphysical` command. Then deduct the number of printouts from the previous command from this number to get how many free slots you have on your motherboard. (Or just open your PC and see how many open slots you have left! You can also install the [Speccy](https://www.ccleaner.com/speccy) app to figure this out.)

wmic memphysical get memorydevices


> ### Understanding the printouts:
> - *Manufacturer* is just the manufacturer.
> - *Capacity* will be the RAM capacity in *bytes* (google will convert it to GB in one search).
> - *Speed* is the RAM speed/frequency in *MHz*.
> - *ConfiguredVoltage* is the configured voltage for this device, in millivolts.
> - *MemoryType* will be a number between 0-26.
> - *Formfactor* will also be a number between 0-23.

> To figure out what these numbers mean check the official windows documentation for [Win32_PhysicalMemory](https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/win32-physicalmemory) and search *Memorytipe* and *Formfactor*.
> Here's a short version though: *Formfactor* 8 and 12 will be the most common, where **8 means DIMM** (Dual in-line Memory Module - the long one that goes to PC's) and **12 is SO-DIMM** (the short one for laptops).
> Regarding *MemoryType*, number **24** (**DDR3**) and **26** (**DDR4**) will be the most common.

## Get RAM specs for Linux:
If you're a Linux user you've probably figured this out already but if not, you can use `dmidecode` to find all the information about your RAM:

sudo apt install dmidecode
sudo dmidecode --type 17

Cool now we have all the specs! Let's see why they're important!
___
## Memory parameters per each
Let's see why each parameter matters and how to do the upgrade keeping these in mind.

### Motherboard Limits
> Swap or add.

You can put as many RAM modules in your machine as your motherboard allows, but the general performance will be a little bit lower the more modules you install. That's why it's better to have fewer, more powerful RAM modules than many with smaller capacity. Modern laptops and PCs usually have at least 2 memory slots.

When you upgrade you basically have 2 options: you swap or you add. If you decide to add a new memory module next to the current one make sure that all the specs align (see bellow).

Also in most machines there's a primary memory slot. It's generally better to put the module with the most capacity to the primary slot.
One thing to mention for older systems: 32bit systems can only utilize 4GB memory max. If you have a 32 bit system every memory beyond 4 gigs is wasted. 

### Manufacturer
> Buy modules from the same manufacturer.

It is said that memory blocks from the same manufacturer generally work better together. If you're installing an upgrade, or you're buying more RAM modules, try to make sure you **buy modules from the same manufacturer**.

### Capacity
> 8GB min, 16GB for work, 32GB+ for high end gaming.

This is the simplest one. Capacity is cumulative (it adds up). Also, you can **freely mix** RAM with different capacities (for example 8GB+4GB).

Question is how much memory you really need? At the writing of this article **8GB** RAM can be enough to run a PC with Windows 10, if all you do is browsing the web and reading emails.
If you want to be safe **16GB** is a good amount to do web development, or anything that requires many browser tabs to be open.
For high end gaming you should go **32GB** or more.

### Speed/frequency
> Faster is better but check motherboard compatibility - or buy the same speed your current memory has!

Generally faster speeds are better, but when doing an upgrade your goal is to **install modules that have the same speed!** (If frequencies differ, the slower can actually slow the better one down to make sure they're in sync.) Also make sure your motherboard supports the frequency of your RAM.

### Voltage
> Buy low voltage, or the same voltage as your current RAM.

There can be cases when your motherboard will not be able to operate your RAM if it requires more Voltage than what the motherboard provides. This can usually be set in the BIOS, but to avoid inconveniences make sure to buy the same voltage that your current memory has. Also lower voltage is generally better, and more cost effective.

### Memory Type
Easy. Buy what your motherboard supports/what you currently have (DDR3/4/5)

### Form Factor
Same. Buy the supported type (DIMM/SO-DIMM).

### CAS Latency
> Select the lowest latency or buy the same CL as your current RAM.

CAS Latency, or the CL number is a bit more complicated. You should generally **install modules with the same CAS Latency**! But it's not that simple to figure out what your system currently has. Here are some ways to find out your current RAM CL:
- Search the manufacturer's site, with your serial number. Here's how you get your serial number:

wmic memorychip get serialnumber, manufacturer

- Install [Speccy](https://www.ccleaner.com/speccy) app and check it there.
- Open your machine and check on the RAM sticker (it may or may not have the CL number on it).

## Summary
> If there's more than one RAM module in a machine the following parameters should be aligned: **manufacturer, frequency, CL, voltage**.

> **Form factor, type, and compatible frequencies** are specified by the motherboard manufacturer.

![memory install](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tmori15gfdexvpb30red.gif)

## Install and Check!
If you've got the RAM that fits all the requirements, all you have to do is to **shut your machine down, make sure it's not plugged in and battery is removed**, then install the RAM.

After restarting your machine you can check if your new memory block is operated properly by your system.

### Windows

systeminfo | findstr /C:"Total Physical Memory"
wmic memorychip get capacity

### Linux

free -m
sudo dmidecode -t 17


Also keep in mind: if everything should be okay but the RAM is not working, it can easily be a *faulty/broken* module. It happened to me before.

**Enjoy your upgraded RAM!**
![plusone](https://thepracticaldev.s3.amazonaws.com/i/ypvzafveynm5q1njmrs3.gif)

How to realize your client's random app idea

Richard Lenkovits — Tue, 07 Jul 2020 19:18:36 +0000

"So you're a software developer? You know I've got this app idea..."

Sounds familiar?

I think software developers can all relate to this situation. Everybody has random app ideas, especially your family and friends when they realize that you've got what it takes.
On the other hand, we developers are not devoid of ideas either - it's just we know the market (which is saturated) and the process (which is whacking).

And I'm not talking about coding. Hell, that's actually the fun part! - after all the work you have to put into consolidating business logic, creating UI/UX design, user workflows, database schema, etc.

Luckily we can usually control our friends' desires - but let me paint you a different picture.

Here's the same thing but with a twist:

"I've got this app idea... And I'll pay you to do it."

OK. You might be asking - that’s just the tip of the iceberg, what are the variables? Money, complexity, platforms, who are you going to work with?
Bear with me, because I’m going to show you how I tackled this challenge! I hope my example will help to explain a few things.

Here's the story.

Idea meets me

Truth be told I count myself extremely lucky.
It was a small design studio who first found me with this kind of request and there were extenuating circumstances:

1. The application started as a proof-of-concept thing.

They planned to iterate on it, trying out ideas during development, so nothing was set in stone.

2. I had a lot of freedom.

Which is a blessing and a curse as well. A blessing because I had a chance to try out new stuff, experiment, and learn. I'll elaborate on the curse later...

3. The app was not going to go full-public.

It was planned to be used only between co-working companies. No huge responsibilities, or significant business security concerns.

Just some details. This was a full-stack web app (PERN stack), with user authentication, separate admin/user interfaces and artifact management - consequently involving a database and storage service.

All the above meant that I had space to learn, improve, and make mistakes, while being paid for it.
Here’s the real kicker though: for me, it would have worth it even without the money - just for the experience.

Idea meets technology

The first bumps along the road came when I realized that my client's app idea was as undeveloped as any random idea, people usually come up with. They could describe the apps main purpose, plus they had some design sketches, but that's about it. A good old idea.

No admin/user interface or workflow design - basically no ideas on how admins should be able to configure user privileges and manage data. Literally nothing to help me figure out the database schema and the supported operations.
The wanted to manage ambiguous artifact types.
Also, they had super flexible role-based access management expectations.

This is where freedom can become a burden because you end up to be the expert who is expected to bring the best of all worlds:

1. Find viable, sustainable, and scalable technical solutions...

2. ...but also don't steer to far from customer expectations...

3. ...while writing super flexible code to be able to redesign on a whim.

The solution for me was twofold: asking the right questions, and managing the product responsibly. Let me explain.

Ask the right questions

You can easily end up in a situation where your app specification is something like this:

"I want to be able to log in and like... upload and download stuff. Then users could register and can download stuff. But certain people could only download certain stuff!"

Normally you wouldn't get a "specification" like this at a web development studio. You would get interface design sheets, database schema specs, maybe even a complete design theme.
You're not that lucky this time. Now what.

Well, you cannot teach product development to your client, especially if you're also inexperienced - but you can ask questions until a working solution unfolds! Basically: Review, build, synchronize.

In steps:

Review your client's feature requirements.
Construct technical solutions.
Align technical implementation details and constraints with client expectations. Educate your client.
Adjust your implementation to be in accord with your client's needs.
Rinse and repeat.

Be thorough, I can’t stress this enough. It can be super annoying to redesign a whole database or API, just because you were not extensive enough in explaining limitations created by a certain implementation choice, at a certain point.

Be your own product manager

At large software companies, you always have a team lead, or some kind of manager, who serves as the first layer of defense.

Basically how it works:
Other parts of your company may throw implementation ideas and random tasks at you, and your manager is the one who decides what tasks are accepted, depending on your team's experience, scope, time restrictions, etc.

As a freelancer, you'll have to step up and steer your client away from design ideas that would result in harmful technical decisions.
Communicating technical debt is not trivial, and there are whole articles about it.

The point is, we can do anything with code, but it doesn't mean that we should. As the developer, you should be the one who draws the line.

Careful source code management is also key. You won't be able to adapt fluently if your git repo is a mess. It's pretty hard to revert features if your commits are not granular enough and you don't document well with proper commit messages and tags.

Everything has a price

If you're alone, or you have little help (like a couple of designers throwing concepts and UI mockups at you - which is not always help, let's be honest) you probably have to consider what you're capable to do alone given a specific amount of time and resources. When your client wants something beyond your limits, the best is to expose these limitations and the price they might have to pay (in time, or resources) to accomplish what they want, despite the boundaries.

I hope you've enjoyed this read! Happy coding!

Hospitality should be automated. Here's why.

Richard Lenkovits — Sat, 04 Jul 2020 19:54:55 +0000

Just a heads up: This is more of a blog post, noting technical. 🍹

The better version

This summer I visited a small historic town in the countryside with my fiance, and one afternoon we ended up at this awesome small restaurant. It was a Tuscany style place in the embrace of the local vineyards above the city, with a great view.

If you've read me before, you might know that I've spent 6 years in international hospitality somewhere between uni and my tech career. As a result, when it comes to restaurant service, I know what's going on, and it's pretty hard to amaze me. Now they've done it. It was a culinary revelation.

Let me just quote some parts of my Tripadvisor review:

Then this guy who owns the place comes forward to have one or two good words with you. You don't have the world's largest menu, but you have top-quality fish, beef, pork prepared with the mastery of an Italian grandmother. I've seen some people complain about longer service times. Bro. I've seen how 5-star hotel sous-chefs work on the food "production line" to get your "fast service"...
...Then you get LOCAL wines with your food. And I don't mean local like "wine from the city that you can buy in Tesco's" kind of local. I mean "from the local cellars that you can't get anywhere" local.

Now I must let you in on a secret. It was not the steak, wines, or the view that won my admiration. It was the sincerity. The candor of the service.

Here’s something you probably don’t know about restaurant people.

They're usually fed up with you.

I'm exaggerating a bit, but a lot of times all the charm that you experience is just part of the facade. There is a particular method to this deceit - it is how hospitality businesses intrinsically work. It's all very simple:

The business owner is looking for the best possible optimization between necessary resource costs and the resulting income potential.

Turns out when you're a hotel or restaurant owner, you don't have much space to optimize. You need good ingredients, competent staff, good equipment. There is still one thing though. As always, it's the human.

The easiest, safest solution is to optimize on the workforce. A little fewer waiters, a single bartender, and a couple of chefs working overtime can run the business!

Well, they will die of exhaustion on the floor, while trying to wear their smiley face, but that's not all!
They will even provide their creativity, humor, and charm to help the owner get away with logistic mistakes and bad business decisions when ingredients, or tools are missing.
Or when people are waiting ten minutes for a jug of water because the boss put only two guys for the fully booked night shift.

Consequently, even hotel bistros end up like franchise restaurants, exploiting their workers, while trying to squeeze out as much profit as possible. When I walk into one all I see is a capitalist purgatory, despite all the amenities. But that's probably just my distorted vision, due to my past experiences.

Now, this is why I really appreciated that small hillside restaurant.

The service was not blazing fast, the food was not always the same, and the wines were different from season to season. Instead, it was real and humble hospitality. They did it because they loved doing it.
These places will never be out of fashion - but let the rest be done by bots!

Obviously, this is not something that happens overnight.

I see that hotels and restaurants employ a tremendous amount of people, and many of them might like their jobs. Though it's a volatile industry - and not even robust, as COVID19 has shown us. I believe in time these jobs can slowly fade and less demanding ones can replace them, as it happened many times in the past. I'm also sure that hospitality done by people will always be something that the rich will indulge themselves in.

I just hope the future will be more righteous in this regard.

Survival package (not just) for devOps newbies

Richard Lenkovits — Thu, 02 Jul 2020 18:39:48 +0000

Welcome to your company!

Landing at a big software corporation can be tough, especially if their onboarding process is outdated - which often is!- along with their unmaintained wiki pages and workflow documentations. Discovering domain secrets is an exhaustive task by itself. The least you need is troubles with general things like coding and communication.

I'm going to share some tools that I regularly throw at newcomers at my place. I hope it can help others as well.

Design Patterns

Not strictly DevOps related, but it can come in handy, especially if you're a Bootcamp developer and you didn't have a lot of software design classes. SourceMaking is awesome, make sure to check out their articles about antipatterns as well!

Linux Basics

A good grasp on Linux systems is key at any software job these days. Linuxjourney is a beautifully designed informative site that helps you understand all the basic concepts.
For detailed command-line help, I suggest the-art-of-command-line by Joshua Levy

Bash Scripting

Bash is an awesome language. It's super powerful and super permissive - consequently super dangerous if you're not sure how to do things in a safe way. Knowing good boilerplate is essential.

Art of biases

Making decisions about software can be difficult, but I've learned that knowing the most common biases can protect us from harmful patterns, general management mistakes, sometimes even from technical debt. That's why this site is awesome. Careful with this one for example. This deserves a whole article.

International communication

You might end up being puzzled by the behavior of your colleagues if you've never been exposed to their culture. This tool of hofstede-insights can come quite handy to decipher some differences.

Just some Less infographics

Large scale scrum is the way these days. I had to include it.

How others do it

It can be really useful to look at other companies' blogs and see how they do stuff. For example, I really enjoy Riot's tech blogs, check it out.

One for the fun

Which is your company? Elaborate in the comments!

18 Common Concepts in Developer Jargon for Muggles

Richard Lenkovits — Fri, 24 Apr 2020 18:44:00 +0000

This post is about my past experiences with tech jargon, during the first two years of my software dev career. I highly recommend it to newbies, especially for Bootcamp devs who are just hopping into the industry.

'It's some kind of elvish...'

I came into software development from a bar counter. Well, I've spent some time being a physics undergrad, so I had a basic idea about cognitively intensive work but still, tech jargon really caught me cold.

I was not totally a muggle, had some programming classes in uni, but that's nothing compared to the experience of people who discuss software related technical problems every day. Not even mentioning that they do this in the context of specific, work-related domains. Coming into this as a junior can be pretty intimidating.

Luckily, tech companies are usually promoting learning, as it's an essential part of almost every developer's job, thus they support bold proactivity and making mistakes during work rather than punishing it.

The bar might be high to get into some well-paying job, but usually, after you've hit that bar, you can indulge in blessed ignorance for a few weeks -sometimes even months- until you catch up with your colleagues in domain knowledge and local practices/tools.

And you'll need this time for sure.

Runes and Incantations

The first thing that I realized as a junior, was that how effortlessly my colleagues can express relationships and issues in a technical topic, using the perfect vocabulary. You know it's much harder to explain "you know there is this string handler operation that finds the domain in the text, that you keep copying around here and there" rather than saying "there's a redundant URL parser in your code, extract it".

In my first days, I've created an 'expressions' note in Google Keep to keep track of all the unknown concepts that I heard flying around me so I could google them later. I still have the note, and I'm still using it! Now I've decided to share it so others could benefit from it. These are not just technical expressions, but also general stuff that people tend to throw around in tech.

Heads up number one: non-native English speaker here
Some of these might not be a big deal if you're native English. Funny thing is: I'm not native English but all these expressions are written English in my notes too - which means these are words that we use in English even when we're talking between Hungarian developers.

Heads up number two: gonna keep it casual
I'm not going to write down huge mathematical definitions, so this is gonna be pretty casual. I'm gonna go with an 'explain like I'm five' approach. Expect 'stuffs' and 'thingies'. I'm also not going into structural design patterns, like Proxy, Decorator, Adapter, Bridge, etc. For those, you'll gonna have to do a Design Patterns course if you don't know them yet.

Here we go!

1. Nested

I thought we could start with a very simple one. I bet this is nothing new, it was just not intuitive for me to use it in a tech context at first. I think it first came up with JSON. We refer to embedded structures as nested ones.

{
  "firstName": "John",
  "lastName": "Smith",
  "address": {
    "streetAddress": "21 2nd Street",
    "city": "New York",
    "state": "NY",
    "postalCode": "10021-3100"
  },
}

It kind of feels stupid to google 'access JSON in JSON' rather than googling 'access nested JSON objects'.

2. Best Effort

It's not super techy, but as a non-native English person, I did not encounter this expression before my tech jobs. Things that we do as 'Best effort' is something that "we do if the circumstances allow it", almost like a "maybe if it's possible, but not necessarily".

3. Race Condition

I thought the official Wikipedia explanation is not too heavyweight here:

A Race condition is a condition of a system where the system's substantive behavior is dependent on the sequence or timing of other uncontrollable events.

In practice, developers tend to carelessly throw around 'race condition' anytime when some process is hitting some other process in the software, resulting in some unwanted behavior (even if it doesn't always refer to that). A good example is when two or more threads can access shared data and they try to change it at the same time, resulting in some unexpected havoc.

4. Literals

A tricky one. In programming, a literal is basically a value that you write to express something literally. With a javascript example:

const a = 30

Where const is a keyword, a is the variable name, and 30 is a literal.

5. Idempotent

A command or function is idempotent when running it several times produces the same result as running it only once.
A good example is the touch command in bash. Creating a file with touch, and then creating a file with the same name as before will not yield a new file on the second run.
But then again, rm is not idempotent, as deleting a file twice will throw an error - as the file is deleted on the first run, and it does not exist on the second run.

Another example is a constructor of a singleton. Running it when the singleton instance was already created does not result in a new instance - just yields the already existing one.

6. Agnostic

This expression is similar to saying something has interoperability. We're using it to describe a high degree of compatibility. So, something is system-agnostic if it functions without knowing the underlying details of a system that it is working within.

Or for example: if a device supports both USB and FireWire, and doesn't care which of these interfaces the data arrived on, it's agnostic, or data agnostic.

7. Redundant

Redundancy is a very common theme in software development and it's a tricky one, as it can be used in a positive and negative sense as well.

Usually, when a developer says that some code is redundant, she/he essentially means that some parts of a program are unnecessary or unnecessarily recurring.
Dead code, unused variables, repeatedly recomputed values can all be redundancy issues. The typical case is when there is a certain operation in functions which is common, thus could be extracted to a separate step to reduce code replication. In this case, redundancy is the result of lazy programming and is generally considered bad practice...

...yet on the other hand, when we're talking about security for example, suddenly there's no redundancy that could be enough! (I'm exaggerating of course.) For example, a repeatedly recomputed value, or a repeated cache validation at the right places can be a great improvement when trying to ensure security. In this case, redundancy is about data validation and is generally considered good practice.

8. Transitive

The math definition is really straightforward, but with a mundane example:

If there's a nice gastro show in the TV during Saturday morning that gets my aunt Theresa in the mood to cook and that results in me eating a cranberry pie during the afternoon, then me having an afternoon treat is transitively related to having a nice cooking show on schedule during the morning.

For me, this expression came up when we were looking at python libraries during work and I had to realize that some python libraries actually have other python libraries as their dependencies - and that makes your code transitively depend on the dependencies of your libs. Wow.

9. Semantics

Okay, this is just a fancy word regarding the 'meaning of a language', or in our case the meaning of syntactically valid strings defined by a specific programming language.

When I say 'python is semantically simpler than Java' I mean that in python many things can be expressed simpler and shorter than in Java.

10-11. Explicit / Implicit

Two very important expressions, often used in programming. Implicit is often used to refer to something that’s done for you by other code behind the scenes. Consider this groovy expression:

def name = 'Richie'

Here I'm hoping that my expression will be handled as a string because groovy implicitly knows that this literal refers to a string, not a number or an array for instance.
But the nice thing is that in groovy I can say this:

String name = 'Richie'

Here I explicitly describe that the literal is a type of String that I'm storing to the name variable.

12. Interpolation

(Parameter Expansion, Parameter Substitution)

String interpolation is the process of evaluating a string literal containing one or more placeholders, thus yielding a result in which the placeholders are replaced with their corresponding values.
You know: Putting the strings into other strings! See the following javascript example.

const condiment = 'pepper'
// interpolation happens here:
const request = `Can I have some fresh ${condiment} on my steak?`

13. Robustness

This is a term often thrown around in DevOps. Robustness is the ability of a computer system to cope with errors during execution. Basically telling how error resistant is something.

14. Benchmark

A benchmark is a certain standard or point of reference against which things may be compared. Basically, a benchmark is an abstract point that we use to express some quality of a system.
Like if my system reached the 3 beer benchmark during a Friday night I'm much more susceptible to end up in a club.

15-16. Declarative / Imperative

A very simple one which can be a bit hard to understand. We like to call programming languages, tools, or design methods imperative/declarative.

I'll start with the ancient sentence:

“You know, imperative programming is like how you do something, and declarative programming is more like what you do, or something."

Better, let's do a mundane example! Let's say you have a puzzle completing machine that you want to complete a hard puzzle with:

An imperative way to complete the puzzle is to describe to the machine step by step HOW to pick up the pieces, and what-and-when to do with them.
A declarative way to complete the puzzle is to tell the machine WHAT the end result should be and let the machine figure out how to get the job done using its built-in mechanics.

React is declarative. Or if you're DevOps, Bazel build language is for example declarative.

In React you're not explaining programmatically how to change the DOM, you're just managing the state changes, and React takes care of the DOM updates for you.
In the Bazel BUILD files, you declare rules in a build graph. You're describing dependencies, but the build steps are run behind the scene for you (though you have some access to the inner implementation, configuration, etc).

17. Dependency Injection

I think this one is one of the hardest to grasp. Dependency injection is a clean coding technique tightly connected to the SOLID coding principles, code testability, and Object-Oriented Programming. Actually it mostly comes up when using classes - and it's a question of how a class/object has access to some resources.

Right now I'm going to give you my way of looking at it:
Let's say you have a piece of logic (let it be a module, function, class, etc). Then let's just say you have another piece of logic as well (let's say it's a service or another function). The dependency injection is when you're providing the reference of the second piece of logic to the first one as a parameter, instead of having the reference right in the first piece.

We like dependency injection because what you essentially do is you decouple the creation and management of a resource from your parent object.
I really recommend this StackOverflow post for references.

18. Lazy Initialization

And we end with a simple one: In programming lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed.

Hope you've enjoyed this small read!

My full stack setup with React

Richard Lenkovits — Thu, 26 Mar 2020 14:25:20 +0000

Summary: In this post, I'll share my React-Express starter app, with some additional details and thoughts. Enjoy!

The stack-nado age we're in 🌪

Currently, we're living in times when it can be pretty hard to decide what technology is the best for our application. Although this confusion is actually just a facade - we're perplexed by the many colors of screwdrivers that we can pick up.

Don't get me wrong, clearly, technologies have their areas of expertise, as they're all born to solve a specific problem. But the thing is, we humans are quite good at the abstraction of problems - which results in us identifying similar root problems. This is how tools like Angular and React end up solving the same issue - modularized frontend. Also, this is why developers tend to say, that more often than not, your stack is just preference, rather than technical necessity.

Picking a screwdriver

What I can tell you, however, is how I do/did these choices. I believe I'm a very versatile coder - one might say "Jack of all trades, master of none". What this means is that I'm not afraid to touch any part of the development process let it be frontend design or build optimization.

C'mon, I came to web development from corporate DevOps engineering.

When it was time to choose a js framework/library, I chose to work with React because it was the most popular at that time. What this meant to me, was that it will be easier to find answers for it on StackOverflow. I'm a simple guy.

So this throws out MEAN stack. I was also insisting on using the least possible languages, so to stay in the javascript world LAMP was out of the picture too.

Server or serverless

The next choice is different, as it's more about features than preferences. I love JAM stack solutions, for the ease of deployment and cost-effectiveness that they provide. When it comes to implementation, I prefer to use Gatsby and just let Contentful/Wordpress and Netlify handle the backend.
There are those times however when you want something more than just displaying static instances of some data models.
But still!
Even when I need to create fully dynamic applications with database and login I prefer to use some lightweight solutions - like handling all these things from google Firebase and just stay on JAM stack land.

Fullstack land

Anyhow, sometimes you just can't live without your own API. A lot of times my clients choose to have custom solutions. They don't want to pay to a CMS, or they want to avoid Firebase vendor lock-in, and just prefer to run everything on AWS EC2. Another example when you need to set up some service to support another application.

These are the times when I go for MERN.

Or in my case PERN, as I prefer PostgreSQL over MongoDB. Unfortunately, it can be tedious work to set up all the dependencies and environment for this kind of app (or to undress some developed app just for the setup), hence came the idea to create some template.

So, I've created this super simple application base that can serve as a starting point for these full-stack apps. I've set it up in a way to support all my preferences, like CSS preprocessing, my linter setup, and so on. I'm sharing it hoping that it can help others too when starting a new project having a similar stack setup in mind.

Give us that starter app finally...

Source code is accessible here.
The app is a starter - hence it's super simple. There is a demo of it on Heroku. It's basically just a React frontend that can send two kinds of requests to its server and handle the responses.

It has a Node Express backend where there is an example to help creating sub routers when implementing various API functionality.
The frontend is React bundled with Webpack.
For styling I'm using Sass CSS preprocessor, to support modularization.
Frontend requests are run with Axios.
It also contains my preferred prettier and eslint setup.

Hope you'll find it useful!

An ode to Cross-origin image downloads

Richard Lenkovits — Fri, 20 Mar 2020 14:01:11 +0000

Preface

So I'm developing this app, and my client is like: "Can I have just a download button for the images pls?" And all hell broke loose.

Longer preface

Not long ago I started working on a resource sharing application for a client of mine. They're a design studio, and they wanted to have an app where they can distribute their work/images/source files, etc to their clients. The idea was to have a system where you can create and manage artifacts, users, user groups, and you're able to set up arbitrary access rights between them.

Basically what they needed was something that my designer colleague described as a "google drive on drugs".

So we made it. How? that's a different story.
Anyway. One day my client was like, "It's cool that we can look at the images and right-click download them, but can we have a download button as well?". I was like "sure should be fairly simple". It was not.

Intricacies of the anchor tag

The first solution I found was simply using an anchor tag.
So the anchor tag has this download attribute. Our illustrious helper w3Schools describes it with a fairly simple example:



<a href="/images/myw3schoolsimage.jpg" download="w3logo">

As simple as it could be - so I thought, and gave it a go. But my browser did not give a damn about it and just displayed the image in the same tab. What I did not calculate with was that my images and all artifacts were served from an AWS S3 bucket.

Same origin policy problems

Turns out that in most browsers to be compliant with the same-origin policy, the download attribute only works for same-origin URLs. Hence, it cannot be used to download resources served from a different origin. This is well described in this chrome feature update doc.

Anyway even if it's served from the same origin there can be problems, which need to be resolved using Content-Disposition header. I'm not going to go into this but here's a great article about the topic.

Shortly: To inform the client that the content of the resource is not meant to be displayed, the server must include an additional header in the response. The Content-Disposition header is the right header for specifying this kind of information.

Looking for Workarounds

The first thing I started to look for is some kind of workaround. Cross-origin image usage is well described at the corresponding Mozilla page, but I needed a download. The following StackOverflow post looked like the best approach for me. The point is that :blob and :data are unaffected so we can use a workaround using these, then fetch and emulating the download click.

CORS Errors

After this, a new problem came up thanks to the Cross-Origin Resource Sharing policy. You can read up on the whole thing here. Read it. Seriously it's great and funny. I'm just putting here one quote:

"JavaScript also did not have any special methods to perform network requests at that time. It was a toy language to decorate a web page."

All I needed was to set up CORS on the AWS side like this but you might also be able to use a trick with cors proxies like cors-anywhere.

I hope these links helped others who end up having similar issues.

^{Cover image base Designed by katemangostar / Freepik"}

Finally updated my personal site

Richard Lenkovits — Fri, 20 Mar 2020 09:43:12 +0000

Last year I went full freelance webdev, after some years of corporate employment. It was a very busy and creative period of my life full of learning, and I really wanted to update my old site with my newly obtained skillset. Unfortunately due to this whole covid-19 situation, I really had to hurry to get this site done to be able to put it into use.
So my point is, it's beta, I'm still refining it.

Check it out HERE
For comparison here's the old site.

It's a Gatsby site, using Contentful as CMS. I know it's a bit cheesy but I must admit, I took the idea for the vertical menu from Riot's Valorant.

Have at it dev.to!

From corporate DevOps to freelance full-stack

Richard Lenkovits — Thu, 19 Dec 2019 11:05:25 +0000

I left my corporate DevOps job, to become a fully freelance full-stack web developer - this is a quick post to share some thoughts on it.

Not my first

Till 2019 mid-October I was a DevOps engineer at a global networking and telecommunications company. Meanwhile, I was already working part-time as a hobby web developer, so naturally, I had been considering to go full-time web dev. The stage was set, I knew my client, I had a running project. Clearly, it was not a leap of faith, but when I finally decided to change jobs in October, I was terrified.

You should know about me that I'm not shy to execute a rapid and wild career change. At one point I went programmer from bartender - discussion here:

I'm an ex-bartender/waiter who is now a web developer and DevOps engineer, Ask Me Anything!

Richard Lenkovits ・ Aug 8 '19

#ama

Still, this time was different. I must admit I admired the company for contributing to my career, and I wasn't comfortable to leave them hanging. They accepted me three years ago as a non-experienced university student for an internship. In one year they made me a full-time developer and taught me everything I now know about software. It was an extremely fruitful period of my life, and I was immensely grateful for being able to learn programming, development workflow, tooling, and all about the industry. They helped me enter the world of software when I was just a guy from the street, and I will never forget that.

Yeah. They made it really hard to leave, I give them that...

However, times change

After my first two years, I felt a bit stuck. I admit I'm not an easy personality, I thrive in progress, but I can't stand stagnation. I'm healthy when I can operate at the edge of my capabilities, so that I always learn something with every step, always exploring. If you have ever ended up in corporate software, you know it's nothing like that.

The what and why of industry software development and its weaknesses is a big topic. We can talk about it for endless hours, preferably at a bar counter, given enough beer and wine. I'm not going to get lost in this, but I'll mention a couple of things that really made me consider going freelance in the first place.

Agile Waterfall🌊

A lot of times when some new trend comes up, companies rush and start implementing them in huge overcontrolled waterfall processes. It usually starts on the top, in the head of a selected group of architects. They are like some privileged mages, disconnected from the rest of the company, sitting in a position which was acquired through company politics, connections, and/or age. They usually know nothing about recent trends, and the last code they touched was Fortran and Cobol. At the High Tower these ~~ancients~~ architects sit down and ~~summon~~ figure out some ~~arcane~~ over-architectured ~~tomes~~ blueprints.

These blueprints are then passed down through 666 levels of management until all the visibility and project control is lost in the intertwined threads and yarns of corporate society.

In the end, it arrives at the actual developers, and when someone shouts out that 'But that's not how an API works' it's already late. The abomination must be wrought into code.

Corporate resources + Sunk Cost Fallacy 💸

In the world of startups, you can seriously jeopardize your business if you launch or even start to create a product without extensively studying your targeted consumer group. If you neglect research you can easily end up with an unsellable product.

But this is not the case in a large company! There, if the management wants a tool to be used, trust me it WILL be used.

The situation is especially uncomfortable in the case of inner source software - so code that we write for our colleagues. The corporate bureaucracy that comes with the work usually generates an immeasurable amount of technical debt, and developers must do all kinds of abominable workarounds to comply with unrealistic designs. In the end, the product must be launched and used, whether the targeted users like it or not. And if those users are within the company that can create a very toxic atmosphere.

You don't notice these things first, but slowly during the years they really drove me away from corporate software development.

Then came Freelancer Life

Being a one-man army

After the summer my freelance career started simultaneously with two projects. It was a frontend job at first but it quickly escalated to be a full-stack one as the expectations of my client grew. I learned an immense amount of things in the last few months, and my life changed greatly. Suddenly I had to realize that it's much harder to justify something I wrote if there's no one to do code review for me. The expression of Work-Life balance also started to make sense suddenly.

A freelancer friend of mine warned me several times that I must really pay attention to this or I can easily end up burnt out, or depressed. Indeed the risks and responsibilities that come with being a contractor are considerable sometimes. Not having fix hours can be great sometimes but you can quickly end up messing around during the day and then doing overtime after midnight.

The internet is talking to me

An important benefit now is that I feel as if all the articles and topics that come about on my google feed are for me. This is more because I became a full stack web developer after being a DevOps guy. Now all these blog posts about javascript frameworks, web trends, new tools suddenly sound relevant.

Actually nowadays if you read an article about containers, cloud and site reliability solutions - so basically DevOps stuff - even these are worded for small businesses and web developers because this market is bursting. As a result, picking up and integrating new tech can be hard at a large software company. Previously I always felt overwhelmed when I was working on some DevOps solution with some new tech tool. Reading the tutorials all the help I got was how to make the tool work for some small web app when what I wanted was a setup for the management of many gigantic native telco network applications.

It's great fun to make web apps

Making smaller web apps feel very similar to when I was just creating small tools for fun when I was just a hobby developer. Sometimes working alone can be hard, but I'm happy that I can be more creative and independent.