DEV Community: Hanane Kacemi

TIL: using --no-deps with docker compose

Hanane Kacemi — Sat, 14 Dec 2024 22:14:19 +0000

Currently, I am working on a Laravel project with two containers: one for the web app and the other for the database.

Previously, whenever I needed to update the image used by the container hosting the web app, I had to stop both containers using docker compose stop app db, remove them with docker compose rm -v app db, execute docker compose down, and finally rebuild to apply changes to the desired container using docker compose up --build -d

As you might guess, this process required me to export the database, even if I only wanted to apply changes to the app container.

Recently, while watching some tutorials related to Docker and Docker Compose, I learned about the --no-deps option. This option allows us to apply changes to one container without affecting the other dependent containers.

Now, whenever I want to recreate the app container using a new image, I simply run:

docker compose stop app docker rm app docker compose up -d --no-deps app

There's no need to export the database, remove the database container, or import it again. This process is much easier for me now.

Thanks for reading!

Notes about design patterns

Hanane Kacemi — Sat, 10 Dec 2022 22:36:08 +0000

Design patterns are practical proven solutions to recurring design problems. They are blueprints not algorithms or code to solve a common software problems.

It's important to note that it won't be so simple to look at a software design problem and automatically know which design pattern to use.

Design patterns are categorized into 3 groups :
Creational Patterns : provide mecanisms for object creation which increase flexibility and reuse of existing code. Example : Factory Pattern, Builder Pattern, Singleton...
Structural Patterns : Describe how objects are connected to each other, example : Adapter Pattern, Decorator Pattern, Facade...
Behavioral Patterns : how objects distribute work and how they work towards a common goal.

Design patterns help to have a common design vocabulary between developers. Rather than having to explain the details of a design solution you can simplify the discussion by having a suggestive word to describe it.

One of the design principles is to identify the aspects of application that varies and separate them from what stays the same. With this approach we won't have to make changes in different places when a new request is made by the client, that minimize the amount of bugs that can be introduced by the change and it makes the code flexible.

*1. Strategy pattern : *
Define a family of algorithms encapsulates each other and make them interchangeable. Strategy lets the algorithm vary independently from client that use it

Symfony & Doctrine: Part 5

Hanane Kacemi — Thu, 20 Jan 2022 12:20:51 +0000

Doctrine has built-in methods like findAll, findBy…. For specific needs these functions may not be sufficient, that’s why we can write custom queries with multiples criteria (with join, where,order by … clauses).

Doctrine has its own language, like SQL, to write queries. It's called DQL (Doctrine Query Language), the difference is that in SQL we use Tables & columns and in DQL we use classes and properties.

QueryBuilder object is used to create DQL query, to have a list of jobs that are not expired, we can write a custom query in JobRepository like this :

DQL uses prepared statement which prevents from SQL injection. Instead of concatenating values to the query we use Placeholder (->andWhere('j.exampleField = :val')) and we pass the value via setParameter (->setParameter('val', $value))

To get result(s) we always call getQuery() _function and then we either call _getResult() to return many rows or getOneOrNullResult() to have a single object.

Now, let's assume that we want to get the category of each job. We have a ManyToOne relationship between Job and Category (Many jobs belong to one Category). We can easily have the category using this syntax in twig :
{{ job.category.name }}
But, check the profiler -> Doctrine, we have multiple queries !

We expected to have the 1st one to query all jobs that are not expired, but once we have added the code to have the category in twig, Doctrine had to make other queries to get the name of each category related to a single job, this is known as N+1 performance problem.

This is a good example to see the power of DQL, we can change our previous query as below in order to have one query instead of multiple ones :

 public function findNoneExpiredJobs()
    {
        return $this->createQueryBuilder('j')
            ->innerJoin('j.category', 'cat')
            ->addSelect('cat')
            ->andWhere('j.expiresAt > :today')
            ->setParameter('today', new \DateTime())
            ->orderBy('j.createdAt', 'DESC')
            ->getQuery()
            ->getResult()
        ;
    }

And if we check again the profiler, we have only one query :

That's all, thanks for reading :)

Symfony & Doctrine: Part 4

Hanane Kacemi — Sun, 09 Jan 2022 14:45:57 +0000

While developing a new app, we usually don’t have any data on DB, it’s common to add fake data to do our tests, either manually or using libraries. With Symfony we have a bundle called “Doctrine Fixture”, I tried it and below are my notes about it.

To install it, use: composer require orm-fixtures --dev
New folder “DataFixtures” is created under “src”, it will contain PHP Classes where we create objects to persist into DB.

I like to keep things organized so I will create many fixtures classes instead of adding all dummy data to AppFixtures generated by default.

In order to reuse objects across fixtures Classes we use object References(line 32 to 34) and we can get easily the reference in the 2nd Fixture Class (line 15)

When using multiple fixtures, we need to specify the order in which fixtures will be loaded otherwise Doctrine will use the alphabetical order, which may result in errors if objects referenced are not yet created. To do so, we need to implement DependentFixtureInterface and then add getDependencies() to specify fixtures to load before.

To add data to db, we run : symfony console doctrine:fixtures:load

I have also tried an other bundle that helps to generate dummy data instead of setting values manually (if you lack inspiration like me :D ) to add it : composer require fzaninotto/faker --dev

Once installed, we can use methods availables in this library to get a name, address, country, slug, numbers... It's awesome.

Below my JobFixtures class after using this library

more infos on the documentation : https://github.com/fzaninotto/Faker

Thanks for reading :)

Symfony & Doctrine: Part 3

Hanane Kacemi — Sun, 02 Jan 2022 20:34:05 +0000

Previously, I talked about how to create easily an Entity (ex:JOB) using a simple command line make:Entity and answering a few question(fields,type…).

This article will be about saving data to, fetching data from, the database.

Saving Data to DB :

To do so, we need to use a service provided by Doctrine, called EntityManagerInterface. The command symfony console debug:autowiring doctrine shows all doctrine services available.

Type-hint an argument $em to EntityManagerInterface, create an Object (ex $job), set all its properties then call persist and flush methods.

Calling persist() method tells Doctrine that we want to save the object, no query is executed yet. We call this method as many time as objects that we have, once we call flush() method, Doctrine execute the queries needed to insert to database.

We can check if data has been inserted with : symfony console doctrine:query:sql 'select * from job'

Fetching Data from DB :

Getting data(objects) from db is even easier, one way to do that is by using JobRepository $jobRepo as an argument in our method.

The repository class offers many helper methods to get our data from db like : findBy, findOneBy... We can also add custom methods to have complex queries, more about that in my next article.

Finally, I like to mention that Profiler provides a lot of tools to use when developing an app, for doctrine, it shows all queries executed :

Thanks for reading and Happy new year :)

Symfony & Database-Part 2

Hanane Kacemi — Sat, 11 Dec 2021 10:11:19 +0000

In the previous post, we configured Symfony to use Docker for Database, in this post we will talk about Database creation(table, column...) using Doctrine and Symfony.

Create Database :

We can create a database with a simple command : symfony console doctrine:database:create

Doctrine is an ORM (Object Relational Mapper) : Each Table in Database (ex:employee) has a corresponding class in our App (known as Entity, ex : Employee.php) and each column of this table (ex:name) is related to a property of that class (ex: private $name;).

To create the entity class, run : symfony console make:entity

New file is created under src/Entity folder (I like to run after each command git status to check what has been generated by Symfony and access to the file to see its content).

The make:entity command can be used to create an new Entity or to update an existing one (add new property, a constraint...).

Now to create the table and its columns, we need to execute 2 commands, the 1st one is : symfony console make:migration

This command compares the actual state of the database with all Entity classes, if an Entity is newly created or modified the command creates the query for that changes under migrations folder in order to make database matches entities.

To execute this query, we run the 2nd command : symfony console doctrine:migrations:migrate

Symfony is smart enough :D to know if a query has already been executed : The migration system create a table in Database doctrine_migration_versions where it stores all migrations executed :

Thanks for reading and Have a nice day ;)

Symfony and Database

Hanane Kacemi — Fri, 03 Dec 2021 16:40:59 +0000

I'm having free time these days so I decided to go back to learn symfony. I picked up a course about doctrine and symfony. I will post my notes here, feel free to leave a comment, I am open to all suggestions.

Doctrine Installation :

Symfony 5 doesn’t come with a database layer when installing it, to be able to store data in a Database we need to add a library for that, like Doctrine. run : composer require orm

orm is an alias for a library called symfony/orm-pack

Pack is a shortcut to install several packages using one command, for example if we check the github repo of orm-pack, we see that it contains only a composer.json file where we have all dependencies(packages) needed for Doctrine.

Symfony and Docker :

Once the installation is done, you will notice that Symfony Flex added a docker-compose.yml file. Instead of using a local Database (ex :mysql) and attach it to our project let's take advantage of docker and the automatic configuration added by Flex.

Check that Docker is installed on your machine, and then run :
docker compose up -d

To see the mysql Docker container, run :
docker compose ps

To connect to mysql :
docker compose exec database mysql -u root --password=password

Without Docker, you need to configure the environment variable DATABASE_URL in the .env file. Since we are using the local symfony server (by running symfony serve -d) we don’t need that, because when the symfony binary detects the docker-compose.yml file it reads all the config and environment variables of running services and make them available for our app.
You can run symfony var:export --multiline to see the value of environment variables.

To stop a container :
docker compose stop

That's all for today :)

Week 2 : Google PM specialization

Hanane Kacemi — Mon, 04 Oct 2021 20:43:39 +0000

Hello All,

In this article, I will sum up what I have learnt in the course during the week 2 (for those who didn't see my previous posts, I should mention that I decided to wrote articles as a memo of a course that I am taking on Coursera related to Project Management).

So, ready to continue from where we have left last time? :D

This time we will talk about goals and some methods to set them properly.

In the initiation phase, it is important to well-define the goals of your project to get the result expected.
Having goals that are clear for you, your stakeholders and your team is crucial. It helps you and your team to know what to do, it's like having a roadmap, shared with all people involved, to a specific destination.

There is a lot of methods to set goals, one of the most common one is SMART Method (I am sure you know or heard about it before), so what does each letter means?

1.S for Specific: the goal must be specific, not a global or a vague one. For example, saying that you want to lose weight isn't specific, but saying that you want to lose 5kg during 15days, you make it a clear and a specific goal. When setting a goal try to answer these questions: What do I want to accomplish? Why is this a goal? Does it have a specific reason, purpose, or benefit?
2.M for Measurable: You can tell the goal is measurable by asking how much, how many, and how will I know when it's accomplished? Taking the same example about weight, loosing 5kg
make the goal measurable.
3.A for Attainable: what is the purpose of setting goals that are not reachable? goals must be challenging but not so hard to reach, otherwise you lose motivation, and you may give up before attending your goal. For our example, you may decide to exercise 30min during 3days of a week instead of 2hour every day. Break down the goal into smaller parts and see if it makes sense.
4.R for Relevant: does it make sense to try and reach this goal? Think about how the goal lines up with other goals, priorities, and values. Deciding to lose weight, may align with your values: Eat healthy / Avoid food waste / Have a good shape...
5.T for Time-bound: Time-bound means your goal has a deadline. For our example, we assumed that we can achieve the goal in 15days.

Specific, Measurable, Attainable, Relevant, and Time-bound (SMART) goals are very helpful for ensuring project success.

Another method to define goals for a project is OKRs.

OKRs stands for Objectives and key results, it helps to establish and clarify the goal of an organization/Project/Person.

You can learn more about these two methods on the Internet : when it is appropriate to use one instead of the other, what are the pros and cons of each method and more..., and why not share with us what you learnt in the comment section :)

Thanks for reading and have a nice day

Week 1/Google PM Specialization -Part 2

Hanane Kacemi — Fri, 01 Oct 2021 16:28:51 +0000

Hey all,

Today I am going to write about what I've learnt from the course that I am taking currently about Project Management.

As I have said in my previous post,I'm going to talk about CBA(aka Cost-benefit Analysis).

CBA is a process that is used to compare project benefits to its costs, the goal is to reduce waste and invest resources responsibly.

Project Managers don't make decisions based on gut instinct, they ask questions, gather data to analyze, use tools...

Below are some questions to consider when determining the benefits and costs of a project.

Example of questions to determine benefits :
1.What value will the project create ?
2.How much money could this project save ?
3.How much time will be saved ?
...

Example of questions to determine costs :
1.How much time will people spend on this project ?
2.What will be the one time cost ?
3.Are there any ongoing costs ?
...

There is many ways to calculate costs & benefits of a project (known also as ROI : Return On Investment), here is one of them :
(G - C)/C = ROI
G : Financial Gain
C : Costs

Let's take un example to calculate ROI :
Consider a project that costs 5000$ upfront plus 25$ per month for 12 months. You estimate that the project will gain 10000$ using the formula above, ROI = (10000-5300)/5300, the result is : 0.88 or 88%.

Depending on the ROI, the project manager and stakeholders will decide to pursue the project or not.

This is the end of this post, thanks for reading it.

Have a good day :)

Week 1/Google PM Specialization

Hanane Kacemi — Sun, 26 Sep 2021 20:25:59 +0000

Hey all,

Recently I've started the second course of Project Management specialization created by Google and titled : Project Initiation : Starting a successful project. I decided to post my notes here as a memo.

Week 1 :

Initiation phase of the project life cycle :

Among Project Manager responsibilities during the project initiation phase we find:

Identify goals and resources based on initial discussion with stakeholders
Ask the right questions to stakeholders, perform research
Document the key component of the project.

Getting in the same page with the stakeholders, by clarifying the goals of the project, will save a lot of time and extra work for everyone throughout the project.
It's a crucial phase, because it determines how well the goals will be met, and it ensures that the benefits will outweigh the cost of the project.

Key component of project initiation :

The key component to concider during the initiation phase are :

Once key components established, you need to create a project charter, the document that contain all project details to review with stakeholders in order to get their approval so you can start with the planning stage.

Next, I will write about cost-benefit analysis and its importance in project management.

Have a nice day all :)

My notes about Google Course titled "Foundations of Project Management" -Part 2

Hanane Kacemi — Sun, 15 Aug 2021 18:46:25 +0000

Hello,

As mentionned in the title, this is the 2nd part of my notes about Google Course "Foundations of Project Management", here you can find the 1st part.

Exploring the phases of the project life cycle :

The project life cycle has 4 major phases

Introduction to lean and six sigma :

Lean Six sigma are commun for projects that have goals to save money, improve quality and move through processes quickly.

Six Sigma : Reduce variations by ensuring that quality processes are followed every time. Below the 7 key principales :

Always focus on client
Identify and understand how work gets done
Processes flow smoothly
Reduce waste and concentrate on values
Stop defects by removing variations
Involves & collaborate with team
Approach improvement in systematic way

Overview of classic and matrix structures :

Organizational structure refers to the way a company or organization is arranged or structured. There is 2 type of organizational structure :

Classic : Top down hierarchy, CEO has direct authority over several department manager
Matrix : Employees can have 2 or more manager

Reporting charts :

shows relation between people and groups within the organization and details who person or groups reports to.

Introduction to organizational culture :

Organization’s culture provides concepts and acts as a guide for what their people value, how they operate on a daily basis, how they relate one to another…

Change management :

is the process of delivering a project and getting people to adopt. When project managers understand change management and their role in the process, it helps to ensure a smooth rollout and easier adoption.

Steering committees :

Advisory board or council to help the Project Managers and the company make and approve strategic decisions that affect the company and the project.

I Hope that those 2 posts will help you to have an overview of the Coursera Course "Foundation of PM" By Google.

My notes about Google Course titled "Foundations of Project Management" -PART 1 -

Hanane Kacemi — Sun, 15 Aug 2021 18:21:48 +0000

What is a project ?

A project is a series of tasks, with a beginning and end, that need to be completed in order to reach the desired outcome.

What is the project Management ?

Application of knowledge, skills, tools and techniques to meet the project requirement and achieve the desired outcome with respect of budget and time.

What does a project Manager do ?

Follow a process that involves :
- Planning and organizing
- Managing tasks
- Budgeting
- Controlling costs and other factors.
Assure that the project will be completed on time and within budget.
Bring value to the company.