DEV Community: Mirosław Farajewicz

10 most useful IDE hotkeys with GIF examples [part II]

Mirosław Farajewicz — Fri, 13 Dec 2019 13:47:04 +0000

This is the second part of the article that had a really warm welcome in dev.to community. Some of you commented on your favorite hotkeys, some asked about version for different IDEs. First things first, I want to finish with a set of another 10 hotkeys that will make you the master of hotkeys.

During my work as a dev I use all of them every day (or almost every day).

They are solid background for being really prolific in code refactoring.

As I mentioned in the first part this keymap is based on Netbeans. In most of modern IDEs you can choose this one (definitely in Eclipse, Netbeans and Jetbrains Family of IDEs such as PHPStorm)

Ok, this is an article for better productivity, let’s not waste time for more theory.

1. Ctrl + G - Go to Line Number

This is pretty self-explanatory. What is cool about this hotkey it works in environments such as Notepad++, Chrome Dev Tools. You can also type a character number after “:” mark. 170:35 means go to 170th line and put cursor on 35th character.

2. Ctrl + Tab - Show last opened files

This particular hotkey is extremely useful. I think it goes just after the podium of Ctr+C, Ctrl+V and Ctrl+S in daily work. If you’ve never used it, here’s how it works. You press CTRL then holding it for the entire time press Tab. Every Tab stroke is moving selection to the next file from the list. Releasing Ctrl will open the selected file. After using the list is naturally reordered.

The guy who first came with this idea in IDE should be rewarded with a Nobel-prize equivalent for UX inventions.

3. Alt + Shift + V - Extract variable

Number 1 hotkey for refactoring. Together with the one presented as next you can un-spaghetti your code very easily. PHpStorm which I’m using detects multiple occurrences of code that should be extracted to a variable and replaces all occurrences.

4. Alt + Shift + M - Extract method

Works extremely smart in modern IDEs - it detects parameters and return value but it also allows you to customize signature. If you have big blocks of legacy code that are written according to God-Class antipattern it’s the perfect moment to learn this shortcut. If there are moments you want to extract some block to separate method, but you are afraid of multiple dependencies (parameters) this hotkey will automatically detect what is needed.

5. Ctrl + Shift + H - Replace in project

Perhaps this GIF is not an ideal example as it doesn’t show what happens after confirming changes. It was hard to squeeze usage of this hotkey into a few seconds GIF.

Basically, it’s like Ctrl + H (replace of string) but working in the scope of entire project or selected directory.

6. Ctrl + Shift + I - Optimize imports

Self-explanatory. Removes all the unnecessary imports. As you probably guess, it works only with languages and frameworks that support imports.

7. Alt + Left/Right arrows - Jumping in code tree

Great shortcut for navigating in complex code-base written with many layers of abstraction. Sometimes you click on method signature to check its code, then you go deeper and deeper. And then you want to go back two levels up. You can return using shortcut #2 or using this hotkey.

8. Ctrl + minus/plus - Collapse / Expand block of code

Useful in God-Class files containing 5k lines of code. Also, I tend to use it for huge configuration files written in YAML, JSON or plain PHP.

9. Ctrl + Shift + T - Go to test

Goes to test file (if exists), prompts to create test file or returns to the tested class file. If you have more than one file matching pattern it will open dialog with possible options. It can be replaced with hotkey #2 (as long as you opened both class file and test file), but anyway it’s good to know it.

10. Alt + Shift + F6 - Run test

Runs test in the current file. If you are the lucky guy working with a codebase that is heavily covered with automated tests you can save some seconds by using this hotkey instead of clicking on a green arrow icon somewhere in the menu of your IDE.

So that’s it. Positions 11-20 of my hand-picked set of most useful hotkeys. My proposition for you is to immediately test some of them in your IDE. The longer you keep a non-hotkey way of navigation, the harder it will be to learn this productive habit of using shortcuts.

Go beyond CTRL + C / CTRL + V and learn using some of the #20 starting from this very moment.

If you liked formula of this tutorial follow me on twitter to get notifications of other upcoming tutorials. When it comes to hotkeys I plan to publish a series of “Refactoring patterns on GIF examples”. It will illustrate combinations of hotkeys on real-life examples of refactoring.

Also, I think about creating “20 most popular hotkeys” with a keymap different than the Netbeans one.

6 GitHub Repos For Instant Knowledge Boost

Mirosław Farajewicz — Thu, 28 Nov 2019 15:12:38 +0000

Github is not only a place for storing our code and sharing libraries with other developers. Thanks to powerful Markdown syntax it’s possible to create sort of wiki pages. There are thousands of great resources in the Github - some of them are so big that recommending them is pointless.

Saying “Heh, checkout Awesome-List repo*” is like saying “Hey, there is this awesome website where you find anything, it’s called Google”

That’s why I would like to focus on smaller and more single-subject repositories.

* Awesome-list is the biggest list of links and resources for developers

Effective Engineer Notes [4 min read]

https://gist.github.com/rondy/af1dee1d28c02e9a225ae55da2674a6f

This small repository is like a single article or checklist for software developers who want to

Improve speed of the dev process
Learn quicker by improving learning habits
Be more focused and productive while coding Except focusing on being more effective it gives you some hints on how to be a better software engineer. Most of the tips are highly inspired by knowledge spread by software architect guru Martin Fowler.

Great things that should be highlighted from this repo are for sure: Invest in Iteration Speed and Fail Fast sections.

Also at the bottom, there is a bunch of other resources, but I did not get familiar with those yet.

Tech Interview Handbook [1 day read]

https://github.com/yangshun/tech-interview-handbook

Great resource for any developer who struggles with passing through interview process.

Algorithms section is cool packed piece of knowledge we all learn at first year at any university but then we forget it till we graduate and look for a first job.

Part of During the Code Interview is also a must.

Big List of Naughty Strings [not for reading I guess]

https://github.com/minimaxir/big-list-of-naughty-strings

Inside the repository, there is a file blns.txt. It contains a long list of strings that you may use while testing user inputs in your app.

If you have a unit test with a data provider specified it may be pretty quick to implement a part of the list for the most crucial part of your app.

The most important part of the list itself?

Definitely #Script Injection part - starts around line 320.

Free Programming Books [your entire life]

https://github.com/EbookFoundation/free-programming-books

Well this repo is a little exception from what I wrote in the introduction. It’s huge. If you were to read everything there one life would be not enough.

Free for dev [30 min read]

https://github.com/ripienaar/free-for-dev or just https://free-for.dev/#/

This is a list of tools that you may use in your daily work. Requirement for tools on that list is having some kind of free plan. You may be sure that if you don’t have enterprise needs you’ll find free apps here. The cool thing is that it’s focused on typical dev applications, so there is just one section for app like Jira or Trello - which normally are listed on any “X best tools for developers”.

Sections you need to discover: Miscellaneous as it contains completely random things you may even know that exists. Also Api & Data part is great.

You Don’t Need [few hours read]

https://github.com/you-dont-need/You-Dont-Need.com

Great repository that gathers different articles written in a “You don’t need X” way. This is mostly set of tips why developers these days over-engineer apps. Especially in JS ecosystem world people tend to use frameworks and tools because there is a hype for them not because of real need.

I would say this reading is a must.

You should start with You Don’t Need to Transpile Your JavaScript.

Thanks for reading my list. I hope you not only bookmark those repos - bookmarking is easy. But I truly hope you’ll read and use some of them.

The power of those repos lies in the fact that most of them are created by programmers from the passion.

They are not yet another marketing product to promote some famous dev company.

What are your famous wiki-repos? Comment bellow. And yep we all know Amesome Repo :)

Follow me on Twitter at @mfarajewicz to stay up-to-date with my publications.

Error-logging Patterns and Practices

Mirosław Farajewicz — Wed, 27 Nov 2019 12:36:52 +0000

This article is an extension of what I wrote in 5 tips for dev rookies. The idea behind the original article was to overly describe important concepts that you can improve in your work.

I wanted to deliberate a bit more about logging, so I decided to create a separate article.

Should I care about logs?

With broken logs you would be walking alone in the dark when searching for a bug. What’s more, with logging mechanism not implemented at all you won’t even know that there is a bug.

With logs, you can simply start the day with a mug of coffee and check what errors happened during the last few hours in the night. If these are known issues then you won’t appreciate it so much**. However, if something new and unexpected occurs you may be sure that a well-formed stack trace with a meaningful error message will make you think “I got you, you little fu**&”.

With logs, you can easily find what happened on your customer’s account without a bigger interviewing session.

How you can tell that there is something wrong with logging in your application? Well, it can be broken in many different ways.

I won’t dig this topic so deep to debate which logging library or log processing pipeline is the best (well processing pipelines are not very junior dev topic). I would like to discuss a few more basic and overall concepts.

** Which means that they either should be fixed or you log things that perhaps should be omitted?

Understand your framework

Most of the modern frameworks (at least the backend ones) have built-in functionality of logging. While logging information and warning messages are self-explanatory, dealing with errors can have different scenarios and many developers just omit this knowledge and follow approach “ok I will use any method for logging and it will be fine”. Well, it won’t be fine. What’s worse by using logging methods in the wrong way you are turning logs into garbage.

Some libraries log errors using a method like error(message) and it produces entry with your log with that message, timestamp and log level.

Some have separate method for logging exception object such as logException(Exception e)

which usually takes an exception message and combines it with a stack trace and then puts that as an error entry to your log.

It’s also popular to have one method such as error, but with the possibility to add context or exception object - then the method extracts stack trace and builds proper error message on top of it.

Spend 2 minutes on reading documentation in the #logging section of your framework or logging library.

Code-level mistakes

There are many basic code-level mistakes when using the logging mechanism in our app. Most common are those when dealing with exceptions.

For the sake of example let’s assume our app is a web scraper extracting data from some job board. We want to get details of each job extracted from the main page of our target job portal. We are requesting pages using abstract HttpClient.

Before we start let’s imagine a little mind experiment. For each situation - imagine what your co-worker would see in the log on the next day morning when he starts his day in the office, assuming that some error occurred in the piece of code written by you.

Not logging exceptions at all. I’ve seen this way too many times in codebases.
try { httpClient.get(url) } catch (e) { }

Assume that your app scraping was supposed to scrap 2 thousand URLs and failed on yetanotherjobboard.io/junior-web-dev.

Monday, morning. Your coworker is enjoying his first coffee - while checking logs to learn what happened during the night. What would he see in logs?

Nothing, blank.

You don’t even know that during the night some of the URLs were not parsed.

Fixing logging, in this case, is obvious. Assuming that your logException method deals properly with logging exception and does not commit any of the next mistakes it would like like this

try { httpClient.get(url) } catch (e) { logger.logException(e); }

This example assumes that logException method saves every important piece of information. Otherwise, we need to separately save exception and information about it. See the next examples

Logging without adding details about what went wrong.

Try {

httpClient.get(url)

} catch (e) {

logger.logException(e);

logger.logError(‘Was not able to parse URL’);

}

That’s better than problem 1) because at least we know something unexpected happened but still missing a crucial part of the problem. It’s also an example of what I mentioned in “Understand your framework” section. We have two separate methods - one for logging exception itself, and second if we want to save entry with our own error message.

What would your team-mate see at the morning after parser failed to process one of the URLs?

Stacktrace with line of code of you HttpClient failing.

Plus next log would be info “Was not able to parse URL”.

Cool but if you are to fix your parser then you need to know what URL was not parsed. You would like to enter this URL in the browser or curl it in the command-line to manually check why it’s failing.

Fixing this case would make this code like this:

Try {

httpClient.get(url)

} catch (e) {

logger.logException(e);

logger.logError(‘Was not able to parse url ’ + url);

}

Logging exceptions only as error messages. No stack trace logged, which is the same if not more important than a meaningful error message.

Try {

httpClient.get(url)

} catch (e) {

logger.logError(‘Was not able to parse url ’ + url);

}

This example mostly depends on the implementation of logError message but I assume it only logs passed message + marks an entry as ERROR.

In a situation like this you would like to know:

What URL failed - checked
Why it failed - not checked. It may be because the parsed website had a temporary glitch, and we got some 500 response. Our HTTP client could have timeout-ed because of internet problems on our side. Or our parser could have been banned?
Fixing depends on the rest of the code and classes you have, but probably it will be something like this. Stack trace (logging exception itself) will be an answer to our questions

Try {

httpClient.get(url)

} catch (e) {

logger.logError(‘Was not able to parse url ’ + url);

logger.logException(e);

}

Being command-line log ninja

Also at the end, I would like to mention one thing which is a way of dealing with logs. Learn to view them in a handy way. Especially if you are comfy Windows user and have to read logs directly on the Linux machine.

If you are this type of user that first looks for GUI equivalent of every app, and you have to check some logs directly in the command line or DB console you may feel a bit lost. Test those commands for reading logs in Linux terminal:

tail -f -n 200 /var/logs/nginx.log

And make them a habit.

Also adding parameter -F for continuously displaying new lines is helpful

If you have to deal with logs in MySQL console you may find useful SQL switch \G - it makes better display of multi-row columns making log from this format:

Learn how to quickly transform machine-friendly timestamps into readable formats eg. SQL's from_unixtime(col) is a good start. Also, substr function allows to quickly retrieve part of long data for analysis.

Combination of from_unixtime and substr is a simple yet powerful way to find your way through logs jungle.

select substr(LOG_COL, 1, 40), from_unixtime(TIME_COL) as date from LOGTABLE order by id desc limit 10;

Show last 10 logs with readable human time and extracted beginning of log message

Also if you are interested in different time frame you can use DATE_SUB and DATE_ADD methods

Such as

select substr(LOG_COL, 1, 40), from_unixtime(TIME_COL) as date from LOGTABLE where from_unixtime(TIME_COL) > '2019-08-24' AND from_unixtime(TIME_COL) < '2019-08-26';

Those commands won’t make you ninja yet, but they are a good foundation.

What’s next

This is just the beginning of a broad topic of logging. When you get familiar with all the concepts presented in this article you can dig deeper.

Subject such as configuring and using a logging pipeline is what you should learn further. Of course, it’s out of the scope of tutorial for beginners like this. However, using tools such as Logstash and Kibana can boost the quality of your app as it helps you better monitor and alert on anything unexpected happening in the app.

If you like this article get familiar with 5 tips for dev rookies - I will soon write another elaboration on the “Feedback loop” subject.

Also, follow me on twitter if you want to stay up-to-date with all my articles.

5 Tips You Can’t Afford to Miss as a Dev Rookie

Mirosław Farajewicz — Tue, 12 Nov 2019 14:04:03 +0000

If you’ve just started, or you are about to start a career in programming, you probably read many “Tips for beginners”. This is yet another article in that subject. So what is different? I won’t give you a single piece of advice on things like:

which languages or frameworks it is best to learn right now
how to stay motivated coach-like mentorship
how to go through recruitment process
I won’t also debate on whether it’s better to pay for a Bootcamp or enroll to online course.

I will actually address this article to people that already know how to code but perhaps miss some direction on what to devote time when self-learning.

I recently asked myself what was important to me as a developer for the first 2-3 years when learning curve was extremely steep and what habits introduced at the early stage of my development career made strong background for following years.

So going straight to the point, here are my tips.

Junior dev waving to his family seconds before his first release

Concepts and programming principles are important

Together with learning technologies, languages and frameworks do not forget to learn concepts and principles of programming. You won’t be good software engineer if you know 4 different modern JS frameworks, you consider learning fifth but at the same time lack knowledge on principles like:

SOLID
STUPID,
YAGNI,
KISS

And other magically abbreviated principles. It’s like knowing a lot of words in foreign language without grammar skills.

Code smells, anti-patterns and refactoring techniques are also an important concept. Majority of them are pretty straightforward so you can learn them without bigger trouble.

All of them help you create a cleaner and more robust code.

Amazing resource: https://refactoring.guru/refactoring/catalog

Dive into code review world

What it's like being a junior developer in a code review

Good code review is the best way to learn. Period.

If I had one superpower I would make all the people collaboratively review work of their coworkers - whether they are programmers, architects, politics or office-clerks.

There is no better way to spot errors you make, learn how to fix them and how to avoid them.

And there is no better way to learn what mistakes are done by other developers. and what it means to our mental health to read crappy code.

It’s improving our discipline by making us feel twice responsible for our code - we sign it with our name when asking for a Pull Request. And we’ll have to confront other people ready to roast every line of code we produced.

Don’t be afraid of reviewing code written by more experienced people. Even if you are a developer for a short time. You still may find readability issues, provoke discussion and deliver insights from the perspective of a person not so fluent in reading code (this is valuable).

If you look for a job and have few offers - ask about their code reviewing culture - think twice before accepting offers from those not performing any code review or performing it in a poor way.

Logs should be your main point of focus

Logs allow you to sleep better. They will make you more confident about tracking every unexpected behavior in the app.

Logs + automated tests are awesome duo.

Tests cover everything in the code you expect to happen. Also, they assure you other people don’t break this solid foundation. Properly configured logs, on the other hand, will show you that your app or some feature crashed in a way you did not plan.

Overall concepts in having entire logging ecosystem healthy would be:

Log things properly on the level of code and exceptions handling
Keep logs as clean as possible
Automate alerting when number of logs is bigger than expected (this goes beyond the typical junior developer skillset)

When it comes to point 1)

What you need to achieve with logs firstly is to understanding how your framework or logging library works. You want to:

not log unnecessary things - you always should look towards uncluttering logs
log important stuff the way crucial part of information are stored

Once you have this understanding try to fix all the places in your code where logging of exception is broken. With moderately small codebase and modern IDE it’s quite easy to search for every occurrence of "catch(" in the code. And for each occurrence:

Make sure exception is logged.
Make sure it’s stack trace is logged.
Make sure all the important params are logged.

Ok, you have it.

Now last step to become Not-so-Junior Log Ninja is to learn to handle logs in terminal. For the most of your time, you’ll have this comfort to use some web UI. However knowing how to deal with logs in the command-line is an important skill.

Learn favorite commands to view last X lines of log file
Get familiar with continuous log viewing
Learn how to grep
For logs in SQL database learn” \G switch” to be able to view them in a more handy way
Learn how to quickly transform machine-friendly timestamps into readable formats eg. SQL's "from_unixtime(col)" is a good start Learn how to filter logs basing on date using eg. "WHERE logtime BETWEEN DATE_SUB(NOW(), INTERVAL 4 HOUR) AND DATE_SUB(NOW(), INTERVAL 2 HOUR)" to get logs saved in certain 2h window.

Learning what NOT to do > learning what to do

Yep, you’ve read correctly. There is a distinctive difference between learning patterns and anti-patterns.

I’ll give you an example from my personal life. When I was at school I played chess a bit. I wanted to be better so I started to read books and tried to implement solutions from the books.

It didn’t work out though. To tell you the truth, it was a spectacular disaster.

I was using solutions I did not understand. I mean I understood more-less ideas behind each opening or defense but I was missing the bigger picture. Plus for each of them I was so focused on following the set of steps I played like a little monkey.

The result was I playing worse than before I had started to read those books. Shortly after I was not so psyched about chess and stopped playing.

This one tip is pretty personal and some people may not agree with it. It probably comes from how I learn things and perhaps it may not work for every other person.

In learning concepts and principles pay more attention to anti-patterns: what not to do, and what to avoid. In contrary following patterns is doing things in compliance with set of rules.

Following anti-patterns will always make your code slightly less crappy. Depending on the set of anti-patterns and how compliant you are with them - your code will be more or less improved.

But it will be improved.

Whereas following patterns can make you produce code that is even worse spaghetti than before. It happens if you do not understand the bigger picture of used pattern itself or try to implement them too much when not needed (a.k.a over engineering).

Minimize low-level feedback loop

Feedback loop is extremely broad and overall term. It may be related to:

how startups collects feedback from marketing actions they perform
how information flows in IT organization between different members of the team or different departments

But it also may define a set of low-level actions you perform as a developer.

Feedback loop means all the necessary steps to reproduce certain behavior starting from scratch to point when you get feedback - either code is working or not.

Ideally, unit tests should be your feedback and rescue mechanism. But as this article is addressed to junior developers - I assume some of you may not know how to write automated tests.

Learn to minimize feedback loop when figuring out why things are not working.

The ideal situation is to try split longer sequences of work into short ones - making clear save point where you know you can always start from.

Conclusion

I hope that I inspired you to improve something in your work. I wish you all the best in learning and getting better as a developer.

As the last tip I allow myself for tiny work-life balance mentorship: have some life except programming and your job. You’ll be useless for your company when over-worked.. and missing soft skills such as talking to other people.

If you liked this article follow me on twitter or subscribe to my blog to be up-to-date with everything I publish.

10 most useful IDE hotkeys with GIF examples

Mirosław Farajewicz — Tue, 29 Oct 2019 12:39:48 +0000

Do you know what percentage of people do not use Ctrl+F when searching text on pages?

Me neither.

But the closest estimation done by Mozilla & TestPilot says that it ranges between 81% and 90%. The number is pretty shocking to me, but if you think a bit about it - it makes sense. Not all of us work in IT. There are many older people who don’t know that they can “search on webpage” not to mention about using a hotkey for it.

For each of you crushing serious programming challenges every day, there is certain number of uncles and aunties who uses internet mainly for checking recipe for friday’s dinner. 81%-90% sounds not so shocking after having some second thoughts.

Anyway, I’m curious how those statistics look when only IT-related people were examined.

IT loves productivity. Productivity loves hotkeys.

What is surprising many developers did not develop habit of using hotkeys. I know some really good programmers who simply struggle learning them. It’s like developing every habit - you have to put some effort at the beginning, but once you get used to it - it pays off.

For me the Aha-moment for using hotkeys was my first job in office as a developer. Guys who were sitting next to me were extremely helpful. They gave me many tips on more productive usage of my IDE. Without that help I would probably stumble upon the wall of huge and enigmatic keymap in Netbeans which was my main IDE back in the days.

It's not possible to create one universal hotkey tutorial - there are few keymaps out there - most popular are based on Eclipse and Netbeans.

I will review Netbeans’ ones. For the sake of simplicity I named the keys using Windows naming. If you are a Mac user just press CMD instead of CTRL.

Here is my list.

1. Alt + Shift + Up/Down arrows

Used for moving current line of code up or down. When we have selected block of text it naturally moves the entire block.

2. Ctrl + Shift + Up/Down arrows

Duplicates current line of code. In Jetbrains’ IDEs: IntelliJ or PHPStorm it only copies current line below. In Netbeans however it’s possible to copy line up - there is a slight difference in where is your cursor after using the hotkey.

3. Ctrl + J

In Netbeans’ keymap described as “Extend selection” which may be confusing. As you see on the GIF I don’t have anything selected at the beginning so “Extending” this selection is misleading. Selects the entire word / name.

4. Shift + Alt + O

Opens “Open file by name” popup. What is interesting typing name of file using only first letters of camel-cased segments helps quickly opening files with complex name.

Ctrl + Shift + 1

Find current file in directory tree and expand this particular tree branch. Jetbrains products add ability to automatically reflects opened file in directory tree. Personally I do not use this feature.

6. Alt + Shift + F

This hotkey formats current file. Or if we have active selection, formats only selected piece of code.

7. Ctrl + E

Removes current line of code. Works also for selection.

8. Ctrl + /

Comment / uncomment current line of code

9. Ctrl + Alt + Left / right arrow

Selecting consecutive word / expression fragments. If it’s CamelCased name - particular fragments will be selected. If it’s entire expression then adjacent operators and arguments will be selected step by step.

10. Ctrl + R

Rename current element (method, variable, class etc). Replaces automatically all other occurences.

More hotkeys please

So that’s part one of my favourite IDE hotkeys selection. In next episode of this article I will present few shortcuts mostly related to code generation and dealing with automated tests.

I hope that by writing this article I will encourage at least one person to go more towards mouseless navigation.

If you like the form of this article follow me or visit my blog.

Sources: https://blog.mozilla.org/metrics/2011/08/25/do-90-of-people-not-use-ctrlf/

Can I ask for filling a little survey for web devs?

Mirosław Farajewicz — Thu, 24 Oct 2019 14:04:52 +0000

I'm writing an article for my first blog post and would like to know what are standards and practices in other IT companies: https://docs.google.com/forms/d/e/1FAIpQLSeWeWJuGt2Qb05qlCdP5nTnAVJ8DojHvAzEpFvbBO8NcVhKXQ/viewform

Thanks!