DEV Community: Gabriel

Your career doesn't have to stand still just because you're happy at work!

Gabriel — Thu, 23 Jul 2026 08:00:33 +0000

Maybe you’re not looking for a new job.

There is a strange gap in the way we talk about careers. You are either “looking” or you are not.

When you're actively looking for a job, the path is familiar. You update your profile, browse job boards, send applications, talk to recruiters, prepare for interviews, and wait for replies—knowing that many of them will never come.

But if you're not actively looking, you're expected to disappear from the market altogether (why is that?!). As if the only two states are searching or not interested.

Real life is rarely that simple. Many experienced professionals live somewhere between those two states.

Maybe you're returning from maternity leave and work doesn't feel the same anymore. Maybe your company is changing and you're quietly wondering whether your role is next. Maybe you've started thinking about a different career, but you're not ready to commit to a full job search. Or maybe you're happy where you are — you'd just like to know what else is out there. Nothing wrong there!

People don't become curious about their careers overnight. Long before they apply for a job, they often have questions, doubts, or simply a desire to explore. There should be space for that curiosity without requiring someone to become an active job seeker.

They are not trying to escape their current job. They may like working with their colleagues, enjoy the work, and have no intention of resigning. At the same time, they know that the right team, problem, or environment could be worth a conversation. That is not indecision. Cannot stress this enough, this is healthy professional curiosity.

The problem is that most hiring systems do not know what to do with it.

The traditional process asks for commitment too early

An application is not a small signal of interest. It is the beginning of a process. From experience and a lot more people experiences', it's a long process.

It can mean rewriting a résumé, completing forms, preparing portfolios, doing home tests, coding with people watching you live, rearranging your personal schedule, and committing to several rounds of interviews.

All of this often happens before a candidate learns the things that actually matter.

Not the polished recruitment pitch about an amazing culture, a unique mission, or why you'd be lucky to work there. The real things: what the team is like, how decisions are made, whether you'll have room to grow, and whether you'll genuinely enjoy working with the people you'll spend your days alongside. And sometimes, after investing hours into applications, interviews, and technical assessments, there's no answer at all. No feedback. No closure. Just silence.

People deserve better than that. Career conversations should begin with honesty and mutual respect—not with a process that asks for commitment long before either side knows whether there's a real fit.

What problem would they actually be solving? How does the team make decisions? What does the manager expect? Why is the role open? What happens when people disagree? Is the compensation even within range? etc.

For someone who urgently needs a job, the investment may feel unavoidable. For someone already doing meaningful work, declining the process can be the most rational choice.

This creates a frustrating paradox for companies: the people they would most like to meet may be the least willing to apply.

Not because they believe they are above the process. Because they have learned to protect their time.

Experience changes the calculation

An hour spent interviewing is not simply an hour exchanged for the possibility of a new role.

It may be an hour taken from leading a team, finishing difficult work, supporting a colleague, spending time with family, or recovering after a demanding week. A five-stage process creates a real cost long before either side knows whether there is a meaningful fit.

Experienced professionals also understand that a job description reveals only a small part of the job.

Words such as “collaborative,” “fast-paced,” and “people-first” appear everywhere. They say very little about the lived experience inside a company. Also, it could look like red flags.

Culture becomes visible in harder moments. What happens when a deadline is missed? Can someone challenge a senior leader safely? Do managers develop their teams or simply push work through them? Are difficult decisions explained? Does the company close the loop when the answer is no?
Those questions aren't answered by a polished careers page or another carefully rehearsed pitch.

They are answered by people.

By someone who knows what it's actually like to work there. Someone who can talk honestly about the team's challenges, the things that are going well, and the things that still need fixing.

Ideally, it starts with an informal conversation, a coffee chat over video, at a time that works for both of you. No interview. No agenda. Just two professionals trying to understand whether there's something worth exploring together.

The best career conversations don't feel like recruitment. They feel like two people sharing experiences, asking thoughtful questions, and leaving with a better understanding than they had before.

Unfortunately, those conversations often happen late—after the candidate has already invested hours in the process.

A career does not need to be managed through emergencies

Many people begin exploring options only when the current situation becomes unbearable.

Urgency reduces choice. It makes imperfect opportunities appear more attractive and encourages both candidates and companies to compress important decisions into a few scheduled calls.

There is a better time to understand what else might exist: before it becomes necessary.

That does not mean constantly interviewing or treating every professional relationship as a transaction. It means leaving room for relevant conversations without turning each one into a formal job process.

A conversation can provide context without creating an obligation.

It can help a professional understand how another company works. It can help a company meet someone whose experience may become relevant later. Both sides can decide that there is no fit and still leave with something useful.

When there is no immediate pressure to produce an offer or an acceptance, people can ask better questions—and give more honest answers.

The first step should be smaller

For years, we've treated hiring as if every good opportunity starts the same way: with an application.

Update your résumé. Fill out the form. Complete the coding challenge. Meet the recruiter. Meet the hiring manager. Meet the team. Wait. Repeat.

That might have made sense when applying for a job was the only way to discover one.

It doesn't make as much sense anymore.

Experienced professionals aren't usually waiting for another interview process to begin. They're building products, leading teams, solving difficult problems, raising families, or simply enjoying where they are. If you want their attention, asking for hours of commitment before they've even understood the opportunity isn't a great place to start.

The first step should be much smaller. Give people enough context to decide whether a conversation is worth having.

Will I be respected here, or will I spend my first six months proving myself again?
Will this role fit the life I've built outside of work?
Can I trust the people making the decisions?
Is this a place where experienced people are listened to—or just managed?
If I leave a team I enjoy today, what am I really gaining?

If those questions spark genuine curiosity, then a hiring process can begin. Also, the interview process has to change soon, in so many cases it has become ridiculous.

A quieter way to remain open

Quietly Looking is being built for professionals who are not chasing job postings but would still listen when the right conversation appears.

The idea is deliberately simple: allow experienced people to signal private openness without publicly declaring a job search or entering an application funnel.

It is not about sending more recruiter messages. It is not a public résumé directory. It is not a promise that everyone who joins will immediately receive an opportunity.

It is an attempt to create a calmer starting point—one based on discretion, relevance, and respect for people’s time.

Quietly Looking is currently gathering its first group of professionals. This early stage matters because the quality of the community will shape everything that follows. The goal is not to collect the largest possible list. It is to bring together thoughtful, experienced people who share a particular view of career exploration: you should not have to become unhappy, urgent, or publicly available before keeping your options open.

You can be committed to the work you are doing today and still be curious about tomorrow. You can decline applications and remain open to conversations. You can protect your time without closing every door.

If that sounds like the way you would prefer to navigate your career, you can raise your hand quietly at www.quietlylooking.io. Also, it will help us a lot if you added your thoughts on where you are in your career: https://tally.so/r/lb10gV

No dramatic announcement. No immediate application. Just the possibility of a worthwhile conversation, when the right one appears.

This is a longer post from the initial post from LinkedIn: https://tinyurl.com/ymz57xe3

Motion animations with an SVG

Gabriel — Thu, 14 Jan 2021 19:48:30 +0000

I personally think of CSS animations as something complex. While this is still true, I am making steps towards learning more about it, because that's the only way to fill knowledge gaps. I am going to teach you how to animate an SVG, using Figma and CSS. We are going to use Figma because it's so useful to ~see~ and ~group~ the elements that you will later want to animate. For the next steps, I will just assume you have a Figma account and a small project you can tinker with.

Our demo SVG is one from https://undraw.co/ (search for reading) and after some minor modifications, I used it on the front page of my digital garden https://gabriela.codes.

Open an SVG

Choose your image in SVG format and open it in Figma

On the left side, you will see all the individual ids for all the constructed elements. You can hide them, group them, delete them.

Group what you want to animate

We are going to select the character's left leg and group it into one element. Click on one part of the leg, hold SHIFT down and continue clicking on the rest of the items. You will get to a situation similar to this. After that CTRL+G and it will group it. Rename the default name to something that is representative of what you selected, for example: leftleg. Do the same to anything else you think it will be nice to animate, like the clouds, flowers, hands.

After you are done grouping, it's time to export the .svg file with the id attributes like in the image below.

Back to code

The first important part is completed and now we just need to write some CSS to animate our image.

We place our SVG inside a container:

<div class="svg-animation-container">..</div>

And we start adding animations for each group that we are interested into.

Right Leg

#rightleg {
  animation: rotateHand 5s alternate;
  transform-origin: top left;
  transform-box: fill-box;
  animation-duration: 16s;
}

@keyframes rotateHand {
  0% {
    transform: rotate(-5deg);
  }

  50% {
    transform: rotate(5deg);
  }
}

Use CSS rotate() function to rotate in the opposite direction using a negative degree value -5deg.

Both hands

#bothhands {
  animation: rotateLHand 2s alternate;
  transform-origin: top left;
  transform-box: fill-box;
  animation-delay: 1.25s;
}

@keyframes rotateLHand {
  0% {
    transform: rotate(5deg);
  }

  50% {
    transform: rotate(0deg);
  }
}

Clouds going up

#clouds {
  animation: rotateLHand 2s alternate;
  animation-duration: 16s;
}

You can continue to add motion to other ids that you have in your SVG and just play around to see what goes good together. Don’t forget, some people can get motion sickness from too many animations on the screen. Trust me. :)

Trying out Criteria Builder in a Java project

Gabriel — Wed, 09 Sep 2020 11:01:49 +0000

Initially published on my blog: https://documentingiscool.netlify.app/blog/2020/08/how-to-use-criteria-builder-in-your-java-project/

Java, SpringBoot

If you are writing a REST API in Java and SpringBoot for your side projects or at work, I am guessing you have used JPA by now. You probably heard of CriteriaBuilder, but if not, don't worry. I personally have only heard of it a couple of years ago. Looking online on the timeline of this, it appears to be available since Java Persistence 2.0 (Source)

So it's about time I learn the power of writing complex queries in a way that, for example, in a refactoring situation I don't need to change strings in my queries. This is part one of using Criteria Builder (package javax.persistence).

How I used to write queries (long time ago). Do not do this now. It's 2020:

String query = "Select usr.username from PlatformUser usr where usr.companyId = " + companyId;

How I am writing queries using positional parameters in queries:

@Repository
public interface PlatformUserRepository extends JpaRepository<PlatformUser, Long> {
@Query("SELECT item FROM PlatformUser usr where usr.companyId = ?1")
    List<String> findAllCompanyUsernames (Long companyId);
}

What I could do with Criteria Builder:

CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<String> criteriaQuery = criteriaBuilder.createQuery(String.class);
Root<PlatformUser> root = criteriaQuery.from(PlatformUser.class);
criteriaQuery.select(root);
Query query = entityManager.createQuery(criteriaQuery);
List<String> results = query.getResultList();

In order to have access to the entity manager your need to inject it in your repository class.
@PersistenceContext private EntityManager entityManager;

Documentation for Criteria Builder is lacking from my point of view, so I am trying my best to explain line by line.

Example from the demo project:

// Using Lombok plugin for getters and setters
@Getter
@Setter
public class CompanyHandyPersonDto {

    private Long id;
    private String fullName;
    private Long companyId;
    private Long tradeId;
    private String comment;
}

A simple select from a table:

@Repository
public class CompanyHandyPersonRepository implements CompanyHandyPersonRepositoryInterface {

    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public List<CompanyHandyPerson> findAllHandyPersons() {
        // Get instance of criteria builder from an entity manager
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();

        // Create a query object
        CriteriaQuery<CompanyHandyPerson> criteriaQuery = criteriaBuilder.createQuery(CompanyHandyPerson.class);

        // Root of this query (I have no better idea of how to explain this)
        Root<CompanyHandyPerson> root = criteriaQuery.from(CompanyHandyPerson.class);

        // Choosing what data the query returns
        criteriaQuery.select(root);

        Query query = entityManager.createQuery(criteriaQuery);

        // Run the query constructed above and extract the result
        List<CompanyHandyPerson> results = query.getResultList();

        return results;
    }
}

Find a list of objects that satisfy a condition:

@Override
    public List<CompanyHandyPerson> findCompanyHandyPeopleThatAreSoftwareDevelopers() {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<CompanyHandyPerson> criteriaQuery = criteriaBuilder.createQuery(CompanyHandyPerson.class);
        Root<CompanyHandyPerson> root = criteriaQuery.from(CompanyHandyPerson.class);

        // Check against the tradeId representing a specific one
criteriaQuery.select(root).where(criteriaBuilder.equal(root.get("tradeId"), 1L));

        Query query = entityManager.createQuery(criteriaQuery);
        List<CompanyHandyPerson> results = query.getResultList();

        return results;
    }

Find a list of objects with a LIKE condition:

@Override
    public List<Trade> findAllTradesWithNameSimilarTo(String tradeName) {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Trade> criteriaQuery = criteriaBuilder.createQuery(Trade.class);
        Root<Trade> root = criteriaQuery.from(Trade.class);
        criteriaQuery.select(root).where(criteriaBuilder.like(root.get("name"), "%" + tradeName + "%"));

// Or without taking into consideration lower or upper cases
/**
* Predicate likePredicate = *criteriaBuilder.like(criteriaBuilder.lower(pantryItemRoot.get("name")), "%" + input.toLowerCase() + "%");
        *pantryItemCriteriaQuery.select(pantryItemRoot).where(likePredicat*e);
*/

        Query query = entityManager.createQuery(criteriaQuery);
        List<Trade> results = query.getResultList();

        return results;
    }

Find a list of objects that have an Id in a given array of Ids:

@Override
    public List<CompanyHandyPerson> findCompanyHandyPeopleThatHaveOneOfTheGivenTradeId(Long[] tradeIds) {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<CompanyHandyPerson> criteriaQuery = criteriaBuilder.createQuery(CompanyHandyPerson.class);
        Root<CompanyHandyPerson> root = criteriaQuery.from(CompanyHandyPerson.class);

        // Check tradeId is part of the given tradeIds
        criteriaQuery.select(root)
                .where(root.get("tradeId")
                        .in(tradeIds));

        Query query = entityManager.createQuery(criteriaQuery);
        List<CompanyHandyPerson> results = query.getResultList();

        return results;
    }

Return a list of non-empty strings for userFeedbackTitle or userFeedbackDescription (coalesce expression)

Note: a job has userFeedbackTitle and userFeedbackDescription. None of these are forced to have values. Both can be null, both or only one can have values.

@Override
    public List<String> findAllFeedbackThatExists() {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
        CriteriaQuery<Job> criteriaQuery = criteriaBuilder.createQuery(Job.class);
        Root<Job> root = criteriaQuery.from(Job.class);

        // Check title and description and return when one of them is not null
        CriteriaBuilder.Coalesce<Job> coalesceExpression = criteriaBuilder.coalesce();
        coalesceExpression.value(root.get("userFeedbackTitle"));
    coalesceExpression.value(root.get("userFeedbackDescription"));

        criteriaQuery.select(coalesceExpression);

        Query query = entityManager.createQuery(criteriaQuery);
        List<String> results = query.getResultList();

        return results;
    }

If you want to remove all null values from the above example, you can do so by using a Predicate:

 Predicate<String> nullFilter = PojoPredicates.isValueNull();
        results.removeIf(nullFilter);

Find all users that have jobs requests that have the job status- In Progress:

    @Override
    public List<PlatformUser> findUsersThatHaveJobsInProgress() {
        CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();

        CriteriaQuery<PlatformUser> userCriteriaQuery = criteriaBuilder.createQuery(PlatformUser.class);
        Root<PlatformUser> userRoot = userCriteriaQuery.from(PlatformUser.class);

        // Select user and job by user_id
        Subquery<Job> jobSubQuery = userCriteriaQuery.subquery(Job.class);
        Root<Job> jobRoot = jobSubQuery.from(Job.class);
        jobSubQuery.select(jobRoot).where(criteriaBuilder.equal(jobRoot.get("userId"), userRoot.get("id")));
        userCriteriaQuery.select(userRoot).where(criteriaBuilder.exists(jobSubQuery));

        TypedQuery<PlatformUser> typedQuery = entityManager.createQuery(userCriteriaQuery);
        List<PlatformUser> resultList = typedQuery.getResultList();

        return resultList;
    }

It's great so far. Next, I will think of more complex situations where CriteriaBuilder is a better choice.

Here is the GitHub project demo for this: Demo Project Source Code

From design to code

Gabriel — Fri, 29 May 2020 15:39:18 +0000

I wanted to learn how to transform a design/photo into a CSS and Html5 project. That was the starting point at least. Very quickly after I decided to transform them into React.js projects because I use React.js often and wanted a nice theme. Translating a photo into code has always made me uncomfortable because I couldn't do it. In OOP Java world I didn't have to.

Here is the gist:
Project 1: https://blog-react-theme.netlify.app/
Code on GitHub: https://github.com/gabrielaradu/blogreactheme MIT Licence

Lighthouse audit results:

Project 2: https://story-react-theme.netlify.app/
Code on GitHub: https://github.com/gabrielaradu/storyreacttheme MIT Licence

Lighthouse audit results:

The projects are free to use, and I will try to iterate on the code with better practices on the long but without a precise schedule.

Happy coding.

Enhance your technical job opportunity description

Gabriel — Wed, 29 Apr 2020 10:05:52 +0000

Initially posted here: https://documentingiscool.netlify.app/

We are all experiencing a change in our daily life (choices as well) because of Covid-19 (worldwide pandemic, not-a-flu). As job seekers, some of us were caught during job searching, others were furlough or let go and need to find a new job. As companies, some are hiring now and some have frozen hiring.
It is more important than ever now, as a company, to put more work into your job opportunity descriptions. Turn around the question "what can you do for us" from interviews, to "what can we as a company do for you".

Why? Here is some motivation:

It's a business collaboration. Letting aside passion, you need people to work for you as much as people need jobs: for money.
You can fire people if business dictates it and people can leave if their needs dictate that. (Stop blaming people for leaving, you would do the same if the table turns)
You actually want diversity in your team and company. I mean, actually not just for marketing. More details of the interview process translate into more people that are reluctant to apply to actually apply. There is such a thing as an anxiety-inducing interview. It's like you go to a potential client meeting but have 0 information to prepare before.
There are companies that have hundreds/thousands of applicants when a job is made public. Why? because they explain clearly what are the steps for the interview process, they add real-work-description for the job, they pitch their company because they want and need people to help them continue their business.
Time is money, right? You want an appropriate pool of candidates so you don't waste your time and don't waste the candidates time. Yes, there is such a thing as wasting a candidate's time.

I have bundled together some examples (in no particular order) that I found by searching online and with the help from other nice people:

Amazee Labs: https://www.amazeelabs.com/en/careers-amazee-labs Their technical interview is found if you scroll down the page. They don't do "whiteboard" interviews by the way ;)
Basecamp: https://basecamp.com/about/jobs They currently don't have openings, but when they did, the description was soo thorough. Not only for the interview process (technical interview) but for what technologies they use and how. For the last job opening, on the technical side, they asked that you code review together (I hope I didn't remember this wrong)
Automattic: https://automattic.com/work-with-us/how-we-hire-developers/ They have a separate page for jobs, but this one is for describing the technical interview. Everything you need to know as a candidate is written down.
Aula: https://www.notion.so/Engineering-interviews-Aula-bce436a4230c4f0d8b19bc717232d289 This is about async interview which is awesome. They understand a bit of psychology not only tech. Read it, it's comprehensive and clear.
Doist: https://doist.com/blog/remote-job-application-advice/ There is no active technical position but they have blog posts explaining how they hire.
Auth0: https://auth0.com/blog/how-we-hire-engineers/ The post explains very clearly how they are hiring and after reading it, I had the impulse to check out job openings.

For more examples, I have started to add the companies that do the work in this Notion page: https://www.notion.so/Technical-Interview-Process-Explained-Well-f52511e9a32f439a811930703210507a

Knowing that tech interviews can be very toxic and gatekeeping, I am sure that these companies that take the time and make their pitch to potential collaborators will continue to thrive, get traction and thousands of applicants.
Feel free to add to the comments your own examples of companies that hire with a similar approach. I will do my best to add them to the Notion list page. Good news must be shared, especially during these times.

By taking more time to create a meaningful job description, you show much clearer what you are looking for, and more people from the right-for-your-company category will apply. It's very important to acknowledge that not every developer thrives in the same type of interviews. Some like whiteboard questions, some definitely don't. Others like pair programming others appreciate more home tests in their own time and not 'on the spot'. I am going on a limb here, but I have doubts that anybody likes dictating code by phone.

While hiring, it's logic that you get what you ask for. For instance, if you don't mention you do pair programming in the company and in the interview, you might get candidates that never worked like that and they won't pass. This entire process of hiring needs a bit of introspective on your part as well (company part), what you take for granted, what is easy for you is not easy for everyone.

Not fitting your mould doesn't make other people less good. They are probably really good, they just don't shine in your hiring process.
So, empathy is crucial as well as ~~communicating~~ writing your process. Remember, you work with people for people.

New Rest API Endpoint: from start to test in Java and SpringBoot

Gabriel — Thu, 16 Apr 2020 10:33:57 +0000

I want to detail the steps that I try to take when creating a new endpoint in a backend project (Java, SpringBoot, Mockito). Definitely this is not the same all the time, but that's not the topic for this post.

The task is: implement a new endpoint that retrieves all the products that exist at the moment.

Steps:

create a new method in the service class that retrieves using persistence layer (no queries allowed here) all the products available
create endpoint that calls the above service method and returns data
create unit test for service method
create integration test for the new endpoint.

This is my way of testing, you can mix the points as you like.

We are decoupling the persistence (VendorProductRepository) and business(VendorProductService) layers.

public List<VendorProduct> findAllProducts() {
        return getVendorProductsRepository().findAll();
}

This is the actual endpoint, which has one liner in this case. It simply returns the result of the service call.

@GetMapping("/")
public ResponseEntity<?> getAllProducts() {
   return ResponseEntity.ok(vendorProductsService.findAllProducts());
}

This unit test describes the 'given' - 'when' - 'then'. We create a dummy object which we add to a list. The given part is when we describe(stub) what code will do when the repository is asked to return all products. The when part is when we call the service method, and the then part is when we verify the mocked service call returns the initially given list.

@Test
public void findAllProducts_always_returns_all_existing_products() {
        List<VendorProduct> productList = new ArrayList<>();
        productList.add(EntityHelper.convertToAbstractEntity(vendorProductDto, VendorProduct.class));
        when(repository.findAll()).thenReturn(productList);

        List<VendorProduct> foundProducts = subject.findAllProducts();

        assertNotNull(foundProducts);
        assertEquals(foundProducts.size(), productList.size());
}

This integration test, describes the happy path for retrieving a list of all available products. It hits the database so it's best to be made on a developer version of it. We make the Http call and check against the HttpStatus response and body.

@Test
public void testGetAllProducts_shouldReturn_list_of_existing_products() {
        VendorProduct vendorProduct = new VendorProduct();
        vendorProduct.setId(1L);
        vendorProduct.setName("Mint Plants will be deleted");
        vendorProduct.setMinQuantityPerOrder(3d);
        vendorProduct.setMaxQuantityPerOrder(100d);
        vendorProduct.setQuantityType(QuantityType.ITEM.getIndex());
        List<VendorProduct> existingProducts = new ArrayList<>();
        existingProducts.add(vendorProduct);

        ResponseEntity<List> getResponse =  getRestTemplate().getForEntity(getRootUrl() + "/products/", List.class);
        assertEquals(HttpStatus.OK, getResponse.getStatusCode());
        assertEquals(existingProducts, getResponse.getBody());
}

This is when I feel more confident that adding a new endpoint to do something will actually work. This code is actually part of my #twiliohackathon project, so the code is public here https://github.com/gabrielaradu/BuyLocalServerSide

Happy coding.

Unit Testing static classes and methods in Java

Gabriel — Tue, 14 Apr 2020 13:55:52 +0000

Hello, I wanted to share a situation I found a couple of days ago, whilst working for my project for Twilio April Hackathon. I was working on the server-side project and creating endpoints for my product roadmap. What I insist on is testing my code, especially the logic. It's a habit I am actively trying to make.

Let's take this service method that validates a phone number using Twilio API.

We invoke 'fetch' method on com.twilio.rest.lookups.v1.PhoneNumber to receive an instance of PhoneNumberFetcher.class which will later get all the information on the provided phone number if it exists. Great!
Now, how do we test this? We cannot. We cannot mock static classes. So, we need a way to 'inject' our Twilio API call into our logic and test our code as is without worrying about the response from the external API.

Check the wrapper below:

Now, we can update our service method:
*Create getter and setter for TwilioSmsApiWrapper class

Now we can happily create a unit test for our service method:

That's it. Now you have decoupled you ThirdParty Logic from your service and you can unit test your logic without relying on real API calls.
Happy coding.

Send SMS with Twilio Question

Gabriel — Fri, 10 Apr 2020 15:20:06 +0000

Hello, I am trying to use SMS Api to send a message to a real Romanian phone number and the request fails with this error:
"[o-auto-1-exec-1] c.g.l.c.TwilioMessageCreator : An exception occurred trying to send a message to +40******, exception: The 'To' number +40****** is not a valid phone number."

My question is this, can I use SMS API with a Romanian phone number or not? Thanks for the answer.

Update: I figured it out, I created a new project for a hackathon and I could get a phone number to play with.

Twilio hackathon: Buy Food Locally

Gabriel — Thu, 09 Apr 2020 17:58:46 +0000

[Comment]: # Buy food from local vendors. I am trying to bring more features to a situation I found locally, and add the possibility to vendors to create an account and add their products and to safely order food, with a phone number as an identifier. This is a demo project only.

What I am building

Buy food from local vendors. I am trying to bring more features to a situation I found locally, and add the possibility to vendors to create an account and add their products and to safely order food, with phone number and email as an identifier. This means:

a web application for vendors to register themselves, and for customers to order food.

Demo Link

https://buyfoodlocallyfrontend.herokuapp.com/

Link to Code

Backend: https://github.com/gabrielaradu/BuyLocalServerSide
Frontend: https://github.com/gabrielaradu/BuyLocalFrontend

How I built it (what's the stack? did I run into issues or discover something new along the way?)

Backend: Java 11, SpringBoot, Flyway, Hibernate, Postgresql, Twilio APIs: ServerSide, SMS, Phone Number Validation
JavaScript, ES6, React.js, CSS, Html

Additional Resources/Info

Progress Gists:
9.04.2020 ->
Working on my idea for #twiliohackathon hackathon (from home clearly).
Today: new vendor account v1. No password yet, need to update db structure in next ticket. This is the code if you want to take a look: https://tinyurl.com/untyhz8
Must create test profile to stop mucking my db.

10.04.2020 -> 1.Created CRUD endpoints for products.
PR here https://tinyurl.com/uo553tu
Code coverage 100%. I do wonder how long I can keep it this high.
WIP to validate a vendor account phone nr using Twilio SDK.

11.04.2020 -> Verify Vendor Account.
Added possibility to verify a number, send an SMS with a code to that number and create endpoint which checks if the message code matches what is in the database.
PR: https://tinyurl.com/uy5y9a6

13.04.2020 -> Added possibility to create a password after vendor verified their account. Working on security still.
Difficult to concentrate today.

14.04.2020 -> Finished adding JWT, attach a password to a vendor account and login endpoint. Fixed existing failing tests and add some more unit and integration. Two tests that use Test Twilio Creds fail.
PR: https://tinyurl.com/rl4tzah

Need to move to create Frontend client now.
17.04.2020 -> Show list of products
PR: https://github.com/gabrielaradu/BuyLocalFrontend/pull/1
No tests, and weird-looking UI. Need to fix this.

24.04.2020 ->
Finally did the user story for ordering products from two vendors.
Step 1: add your customer phone number. That's how you will get payment link and info about order.

Next, choose what you want to buy. Dummy data (flyway migrations on backend) has two vendors.

Vendor clicks the accept or denies order and customer will receive an automatic SMS with the final response.

A confirmation dialogue will appear if all is good on the server side. By this time, vendors received SMS messages with #twilio API with the customer order.

On the server-side I have implemented logic to create a vendor account and verify it (by SMS of course) using #twilio API, for this demo #twiliohackathon project I think it's enough. I need to redo and add more tests now.

I enjoyed this challenge a lot, reminded that I want to do better on Frontend and enjoy tests more.

Happy Coding.

Remote Jobs for Romania (Europe Timezones) Linkedin Group

Gabriel — Fri, 27 Mar 2020 13:35:08 +0000

Because of our global pandemic with #covid-19, a lot of jobs moved remote, no office, no wasting time on commuting. Better productivity with fewer distractions, spending more time with family and most importantly staying indoors, to flatten the curve. We want to gather specific job opportunities for Europe Timezone, especially for UTC+2 - UTC+4.

If you are a company that hires Remote (Europe timezones), please share the good news and your job opportunities. Going remote (if you are in IT, Marketing, Sales, Teaching, Therapists and other office jobs) is crucial at this time. It can make the difference between 'keeping the doors opened' or not.

You can join us here https://www.linkedin.com/groups/13841181/ and present your job openings in your company.

This group is for ~Romania~ mostly (for now). We are trying to start small and make connections between remote companies and remote workers for trusted long term connections, not gig economy.

It shows that you trust your employees, that you are responsible in society and leave space for the people that cannot work from home. In #Romania, we have a lot of #highlyskilled people that already work either in #outsourcing (a form of #remote) or on internal tools and applications.

Let's give life back to the countryside and local communities.

Remote work as a software company

Gabriel — Thu, 12 Mar 2020 10:17:05 +0000

For the 'not yet believers', if you want you can try learning from people that already are remote and profitable. Remote doesn't mean bombarding your colleagues with videos all day, it's about learning how to write more and not expect an instant response and give time for productive work. A very special note is that if you don't work on your own product, you are already remote for some other company :) Extend the curtsy to the people that chose to work with you.

I like @Basecamp a lot and they extended this offer of buying their book on remote work with full refund. If you are curious, take it!

For the foreseeable future, we’ll be refunding the purchase price of our book “REMOTE: Office Not Required”. Buy a copy, tweet me a picture of you holding the book w/ a sales receipt dated 3/10/20 or later, and we’ll PayPal you a complete refund (DM your email, please).
— Jason Fried (@jasonfried) March 11, 2020

While you are here, I need your help to make (even more) known the companies that create software remote. Big plus for Europe zones, as they are less talked about. Are you working for a remote company that allows remote or is remote from the get-go? Share the name with the world :)

Hire Full Time Remote Software Developers - Project

Gabriel — Fri, 28 Feb 2020 09:28:20 +0000

Hey, me and my partner have been working on a new platform for hiring full time remote technical people (Developers, UX, Writers...) in Europe time zones.
We are working hard to create a decent MVP.
If you are looking for a full time job and want to be notified when we launch, or just find the idea interesting and are curious - please sign up. Thank you very much :)

https://mailchi.mp/ff651b09cbc2/hireremote