Fear not, fellow Instagrammers! There are ways to save those precious Stories, both your own and those of others, and keep them from vanishing into the digital ether. Let’s dive into the different methods you can use to become an instagram story download (in the best way possible, of course).

Saving Your Own Stories: Built-in Options

Instagram offers a couple of built-in features for saving your own Stories.

1. Story Highlights: This is the most straightforward option. Before your Story disappears after 24 hours, tap the “Highlight” button at the bottom of the screen. You can create new highlight categories or add the Story to existing ones. These highlights live permanently on your profile, allowing you to showcase your favorite moments.

2. Story Archive: Instagram automatically saves your Stories to your private archive, even after they disappear from your profile. You can access your archive by tapping the three lines in the top right corner of your profile and selecting “Archive.” From there, you can download individual Stories to your phone or share them again.

Saving Stories From Others: Exploring Your Options

While Instagram doesn’t offer a direct way to save other users’ Stories, there are a few workarounds you can employ.

1. Ask Nicely: The simplest solution is often the most overlooked. If you see a Story you love, reach out to the creator and ask them to send it to you directly. Most people are happy to share their content, especially if you explain why it resonated with you.

2. Screen Recording: This is a quick and easy method, although the quality might not be the best. Most smartphones have a built-in screen recording feature. Simply activate it before playing the Story you want to save, and voila! You’ll have a video recording of it.

3. Third-Party Tools: For the tech-savvy folks, numerous third-party apps and websites allow you to download Instagram Stories. One such tool is Fastdl.app/story-saver, which allows you to easily download stories anonymously and in high quality. Just be mindful of the terms and conditions of these tools and respect the privacy of other users.

Saving Instagram Stories with Fastdl.app: A Closer Look

Fastdl.app offers a convenient and efficient way to download Instagram Stories anonymously and in high quality. Here’s a closer look at how to use this tool:

Downloading Stories with Fastdl.app:

1. Open the Fastdl.app website. You can access this website from any web browser on your phone or computer.
2. Enter the username of the Instagram account whose Story you want to download. Make sure to enter the correct username, as this is how the tool identifies the relevant Stories.
3. Select the specific Story you want to download. The tool will display a list of available Stories from the chosen account. You can preview them before downloading.
4. Click the “Download” button. The Story will be downloaded directly to your device, typically in MP4 format.

Benefits of using Fastdl.app:

• Anonymous downloading: You don’t need to log in to your Instagram account to use Fastdl.app, which ensures your anonymity.
• High-quality downloads: The tool downloads Stories in their original quality, preserving the visual clarity and details.
• User-friendly interface: The website is simple and straightforward to navigate, even for first-time users.

Important Reminders:

• Respect privacy: Always remember that downloading someone else’s Story is a matter of trust. Avoid sharing downloaded content without permission, and be mindful of the creator’s privacy.
• Terms of service: While Fastdl.app is a convenient tool, it’s important to be aware that it is not officially affiliated with Instagram. Using third-party tools can sometimes violate Instagram’s terms of service, so proceed at your own discretion.

Fastdl.app provides a valuable option for saving Instagram Stories, but it’s crucial to use it responsibly and ethically. By respecting the privacy of others and understanding the potential risks, you can enjoy the benefits of this tool while maintaining a positive online experience.

A Word on Ethics and Privacy

It’s important to remember that Instagram Stories are still someone’s personal content, even if they are publicly shared. Always be respectful and mindful of privacy when saving or sharing someone else’s Story. Avoid reposting content without permission, and be aware that some third-party tools might violate Instagram’s terms of service.

Ultimately, saving Instagram Stories allows you to hold onto those fleeting moments of joy, inspiration, and connection. Whether you’re reminiscing on your own adventures or appreciating the creativity of others, these methods can help you build a personal archive of Instagram treasures. Just remember to be responsible and respectful when engaging with other users’ content.

Additional Tips:

• Organize your saved Stories: Create folders or albums on your phone to categorize your saved Stories, making it easier to find specific moments later.
• Use saved Stories for creative projects: You can use saved Stories to create highlight reels, collages, or even incorporate them into video edits.
• Be mindful of storage space: Saving a lot of Stories can take up space on your device. Consider deleting older Stories or backing them up to cloud storage.

By utilizing these methods and tips, you can turn your Instagram Stories into a lasting collection of memories and inspiration.

The post How To Save Stories On Instagram: Keep Those Fleeting Moments Forever appeared first on InSaneProgramming.

The company is now using a neural machine translation system

Google has announced that it is now using a neural machine translation system for all of its translations. This system uses deep learning algorithms to improve the quality of translations.

Google claims that the new system is more accurate

Google claims that the new system is more accurate than the previous one, which was based on statistical machine translation. The company says that the new system is able to generate more natural and accurate translations.

Google is not the only company using neural machine translation

Google is not the only company using neural machine translation. Microsoft and Facebook have also developed their own systems, which are said to be more accurate than Google’s.

Neural machine translation is a rapidly evolving field

Neural machine translation is a rapidly evolving field, and it is likely that the systems developed by different companies will continue to improve in accuracy and fluency.

The advantages of machine learning

Machine learning has a number of advantages over traditional methods of translation.

Machine learning can handle ambiguity better

One advantage of machine learning is that it can handle ambiguity better than traditional methods. For example, consider the sentence, “The cat sat on the mat.” This sentence can have multiple meanings depending on the context. A machine learning system can learn to disambiguate the meaning of a sentence by looking at other sentences in the context.

Machine learning can handle large amounts of data

Another advantage of machine learning is that it can handle large amounts of data. Traditional methods of translation often require hand-crafted rules that are specific to a particular language. Machine learning can learn these rules automatically from data, which makes it possible to translate between languages that have different grammar rules.

Machine learning can be used for personalization

Machine learning can also be used for personalization. For example, a machine learning system can learn to recommend products to users based on their past behavior. This is possible because machine learning can learn to identify patterns in data.

Machine learning is scalable

Machine learning is also scalable. This means that it can be used to handle large amounts of data. For example, a machine learning system can be trained on a dataset of millions of images and then be used to classify new images.

Machine learning is becoming more accessible

Machine learning is also becoming more accessible. This means that it is becoming easier to use machine learning. For example, there are now many software libraries that make it easy to use machine learning.

Machine learning is being used in many different fields

Machine learning is also being used in many different fields. This means that it has a wide range of applications. For example, machine learning is being used for image recognition, facial recognition, and even self-driving cars.

Machine learning is still in its early stages

Machine learning is still in its early stages. This means that there is a lot of room for improvement. For example, current machine learning algorithms are not perfect. They can make mistakes. However, as machine learning gets better, these mistakes will become less common.

There are many different types of machine learning

There are many different types of machine learning. For example, there is supervised learning, unsupervised learning, and reinforcement learning. Each of these has its own advantages and disadvantages.

Supervised learning is where the algorithm is given training data. This data includes the correct answer for each example. The algorithm then tries to learn from this data so that it can predict the correct answer for new examples.

Unsupervised learning is where the algorithm is given data but not the correct answers. The algorithm has to try to find structure in the data itself. For example, it might try to cluster data points together based on how similar they are.

Reinforcement learning is where the algorithm is given a goal but not necessarily the right way to achieve it. It has to try different actions and see which ones lead to the desired result. This can be used, for example, to teach a robot how to navigate around a room.

Conclusion

Google is using machine learning in a variety of ways, including search, advertising, and mapping. It is also making its machine learning technology available to others through its TensorFlow platform.

Machine learning is a powerful tool that can be used for a wide range of tasks. However, it is not a panacea. There are still many challenges that need to be addressed before machine learning can be widely used.

Despite these challenges, Google is making significant progress in using machine learning to solve real-world problems. And as the technology continues to develop, it is likely that we will see even more impressive applications of machine learning from Google in the future.

The post Google turns to machine learning to advance the translation of text out in the real world appeared first on InSaneProgramming.

Tokenization opens up a world of new possibilities for both investors and businesses. For investors, it provides access to a wider range of assets and investment opportunities. For businesses, it enables them to raise capital more easily and efficiently.

Tokenization is the key to linking TradFi with the blockchain. By tokenizing traditional financial assets, we can create a more efficient and inclusive financial system. This will benefit everyone involved — from investors to businesses to the economy as a whole.

What is Tokenization?

Tokenization is the process of converting an asset into a digital token. This can be done with any type of asset, including real estate, commodities, art, and even fiat currency.

Tokenization allows traditional assets to be traded on blockchain-based platforms. This opens up a whole new world of opportunities for investors and businesses alike.

Benefits of Tokenization

Tokenization has a number of benefits over traditional asset ownership.

First, it enables fractional ownership. This means that an asset can be divided into smaller units and sold to multiple investors. For example, a $1 million piece of art can be tokenized and sold to 10 investors for $100,000 each.

Second, tokenization makes it easier to trade assets. Once an asset is tokenized, it can be traded on a blockchain platform 24/7. This opens up new opportunities for investment and speculation.

Third, tokenization increases liquidity. When an asset is tokenized, it can be easily converted into cash or other assets. This makes it much easier to sell an asset when you need to.

Fourth, tokenization reduces transaction costs. Because blockchain platforms are digital and efficient, they can reduce or eliminate the fees associated with traditional asset ownership.

Finally, tokenization opens up new opportunities for investment and speculation. By making assets more accessible, tokenization makes it possible to invest in a wider range of assets.

What Are the Risks of Tokenization?

Tokenization comes with a few risks that you should be aware of.

First, there is the risk of fraud. Because blockchain platforms are still new and unregulated, there is a risk that some projects may not be legitimate. Before investing in any project, be sure to do your research and only invest in projects that you trust.

Second, there is the risk of price volatility. Just like with any investment, the value of tokens can go up or down. If you invest in a project that turns out to be unsuccessful, you may lose money.

Finally, there is the risk of platform risk. Because blockchain platforms are still new and evolving, there is a risk that they may not be around for the long term. If a platform fails, your tokens may become worthless.

Despite these risks, many people believe that investing in blockchain projects is a good way to make money. If you do your research and invest in projects that you believe in, you can minimize the risks and potentially make a lot of money.

How to Invest in Blockchain Projects

If you’re interested in investing in blockchain projects, there are a few things you need to know. First, you need to understand how to buy and store cryptocurrencies. You also need to research different projects and find ones that you believe in.

To buy cryptocurrencies, you need to set up a wallet. There are many different wallets available. 

Once you have a wallet set up, you can buy cryptocurrencies on exchanges like Binance or Kraken. When you’re buying cryptocurrencies, it’s important to keep in mind that you are investing in a new and volatile asset class. Prices can go up or down, and you could lose money.

When you’re researching blockchain projects, it’s important to look at the team behind the project, the technology, and the token economics. You want to make sure that you invest in projects that have a strong chance of success.

Conclusion

Cryptocurrencies are a new and exciting asset class that has the potential to change the way we interact with the digital world. However, it’s important to remember that this is a new and volatile asset class. Prices can go up or down, and you could lose money. Before investing in cryptocurrencies, be sure to do your research and only invest in projects that you believe have a strong chance of success.

The post Tokenization is key to linking TradFi to the blockchain appeared first on InSaneProgramming.

What Is Staff Augmentation?

One of the types of outsourcing, known as staff augmentation, enables you to extend your current team’s capabilities, either permanent or temporary, by using qualified technological resources. Your in-house team may benefit from adding augmented developers or other professionals on a contract basis to address any knowledge or skill gaps. It is important to assess current staff capabilities and identify gaps in knowledge or expertise before bringing in more specialists.
In-house Team, Project-Based Outsourcing vs. Staff Augmentation
Making an initial decision on the business model to use for outsourcing is not a simple task. In this situation, there is no “one-size-fits-all” alternative available since you will need to take into consideration a variety of factors, including the following:

• The cost for the software development.
• Technical skills as well as requirements for the project
• Time-to-market speed and deadlines

Staff augmentation

You will have greater control over the overall development process and the expanded team if you choose to go with staff augmentation. You will be in charge of selecting the candidates, managing the software development processes, and leading the team, and you won’t need to be concerned about the difficulties associated with administrative and organizational responsibilities.

Project-based outsourcing

Through project-based outsourcing, you can have all parts of software development taken care of for you, from the organization of a team to the management of processes. Additionally, there is no need to have in-house technical skills or to spend time working with a remote development team. On the other hand, when consumers use project-based outsourcing, they often have no idea who is engaged in their project, what developers are currently working on, or which choices are made at any given time throughout the software development process.

In-house development team

If you hire a staff to work under your roof, you will have complete control over the project. As a general rule, an in-house team will have the same values as your organization and will care more about the project result.
However, putting together an in-house team involves a major expenditure of money and time. When a business is simply working on one project, employing in-house experts can take a risk that isn’t warranted if the business isn’t focused on technology or software development.

Challenges of Staff Augmentation

Time and language barriers

Communication could become difficult because your staff augmentation partner may be situated in any part of the globe. Because the great majority of people working in IT are proficient in English, the issue of a language barrier has become a thing of the past. Despite this, one of the most typical communication-related challenges while augmenting the development team is dealing with the time differences.
In order to resolve these widespread communication problems, Orangesoft has implemented a number of different solutions. For example, because of the advantageous positioning of our hubs in Eastern Europe, we have office hours that overlap, which makes it easier for us to communicate with one another. This approach has evolved into a pretty standard technique used by other businesses operating within the market.

Concerns about security

When you augment your IT team, you share information with a third party and integrate them into your internal processes. A customer’s data is the primary focus of the security team’s attention since it is vulnerable to compromise.
As a software development agency, we conduct regular security audits to eliminate any potential threats and hazards. At Orangesoft, we ensure your complete safety by following all of the security protocols and signing non-disclosure agreements (NDAs).

Tech competence and skills

In case your augmented team’s performance is not up to your expectations, it is important to reevaluate your development team and your tech leaders. Most of the time, vendors are not responsible for assigning a project manager, managing the development processes, or taking responsibility for the effectiveness of their staff efficiency.

Staff Augmentation with Orangesoft

Orangesoft is not limited to providing just project-based outsourcing services; rather, we provide a full cycle of app development services.
In addition, we provide adaptable IT staff augmentation services that may be performed for any number of professionals you need. You have the option to hire our IT specialists, such as software developers, UI/UX designers, quality assurance engineers, program managers, and business analysts. Choosing to empower your team with Orangsoft, you will have access to highly competent tech specialists who will focus their attention only on the product you are developing.
Our augmented specialists will become essential members of your development team, and you will take care of managing all of the vital aspects of the project, such as planning, supervision, and other significant activities. Because you will be the one to manage your IT professionals, they will feel that they are an integral part of your core team. In case a problem emerges that requires you or your enhanced team to address it, an Account Manager will assist you in facilitating the discussion process.
When you hire Orangesoft for staff augmentation, you’ll go through the following steps:
Examining your initial request
After receiving your request for staff augmentation services, our company’s IT managers and BAs will thoroughly analyze it. Before you request these solutions, there are certain fundamental inquiries that you will need to think about, including the following:
How many different types of experts do you require for the staff augmentation project?
What level of specialist do you need? Junior, middle, or senior?
When exactly should the necessary specialists begin their work?
When is the deadline for your project?
Is it a new or ongoing project?
In order to analyze your request and develop an original team augmentation plan, our managers will require sixteen business hours. After that, we will arrange a call with you or a member of your company to go over all the requirements.

Choosing the experts

Once we have studied the needs and requirements of your project and signed a non-disclosure agreement, we can begin searching for professionals with the required skills and expertise. Then, within the next two business days, we will give you our first CVs.
Conducting interviews with technical experts
Once you approve the CVs, we will set up interviews with qualified professionals. Interviews of this kind often have two parts: the first is with the chief technology officer (CTO), and the second is with the chief executive officer (CEO) or product owner. No matter how many people you interview for a job, you will only have to pay for the individuals who are hired.

Signing a contract

After we finish all the interviews, we sign a contract and get started with the staff augmentation project. After everything has been reviewed and accepted, you will be able to include the chosen professionals in your workflows and development processes. In addition to this, we will appoint an Account Manager who will collaborate with your engineers and assist you in developing a fruitful working relationship with the members of your augmented team.

The post What Is Staff Augmentation and How Does It Work appeared first on InSaneProgramming.

JavaScript

JavaScript (JS) was originally called LiveScript back in 1995 when it first appeared. James Crockford came up with the name “JavaScript” in 1995. He recognized a resemblance between Java and JavaScript, so he chose to call it that because of this. In 1996, Netscape decided to implement JavaScript into their browsers as a means of adding some extra features to the browser’s functionality.
In February of 2005, W3C announced that they reached a decision for JavaScript to be handled under their supervision. This meant that it would be included in the list of official ISO standards and also on the W3C page.

C++

C++ is an object-oriented programming language that is based on the original C programming language. Its main purpose is for creating software and it has been in existence since 1985. Its syntax is similar to that of C, which makes it easier for programmers who are trained in C to learn C++ more quickly.
Objective-C
Objective-C is an object oriented programming language based on C and created by Brad Cox and Tom Love in 1986. This language is used for developing software for Apple’s OS X and iOS operating systems, which are written in C++. Objective-C can also be used with Cocoa SDK to create several different applications.

PHP

PHP stands for Personal Home Page, which was what the creator of this programming language intended it to be used for. However, PHP has evolved into a general-purpose scripting language that is not limited to personal home pages at all. It is now widely used for web development and can even run scripts outside of the web server environment.

HTML5

HTML5 is the fifth revision of the HTML standard; it was developed by the W3C inhaling committee. The purpose of HTML5 is to introduce new semantic elements that are not dependent on any one specific presentation format. It makes it easier for web developers to design their online content with appropriate markup so that it can be interpreted by user agents, such as screen readers or mobile devices.

Python

Python is a programming language that was developed by Guido Van Rossum in 1989. This high-level, general purpose, interpreted programming language has evolved over the years into one of the easiest languages to learn for newbies and one of the most powerful languages ever created. There is also an extended version of this language called Python 3, which was released in 2008. It has the same basic principles as the original with a better programming structure and fewer errors.

Ruby

Ruby is an object oriented scripting language that combines syntax inspired by Perl with Smalltalk-like features. This language also uses an automatic garbage collection, just like most other high level languages, to manage the memory of objects created by developers.

Swift

Swift is an open source programming language for iOS and OS X development that was developed by Apple. This language is not just limited to these operating systems, though; it can also be used to create software for watchOS, Linux, or even Android devices. This new language was introduced at Apple’s WWDC in 2014 and is replacing the Objective-C language in all new projects.

Conclusion

As you can see, there are a wide variety of programming languages used for web development purposes. There are many other options to choose from when it comes to picking a suitable programming language, but these top eight will cover most of your needs. Remember that if you are trying to expand your programming knowledge base then it is advised that you pick up more than one language for use.

The post The Top Programming Languages for Web Development appeared first on InSaneProgramming.

Let us briefly recall what a plugin is. A plugin is an optional dynamic library which implements a given interface. This means that an application which uses plugins consists of a core and plugins. These modules are not mandatory. They can be added and removed at will without reassembling the entire project, and have a minimum number of dependencies between them (ideally – do not depend on each other at all). At the same time, anyone who knows the plug-in interface can create their own plug-in for the application without having access to the source codes of the project.

Several pros and cons of using plugins follow from this definition.

Plugins – pros

Popularization of the application

Adding support for plugins to a project and not counting on this plus is quite strange. Third-party extensions are the main driving force behind the growth of your app’s capabilities and popularity in this case.

You create a robust core and a minimal set of quality plugins. You open up the plugin interface. And if all goes well, you get a lot of add-ons developed by other people. Many well-known IDEs, graphics editors, and other feature-rich applications go this way.

Going to an open-source for an entire project doesn’t provide the same benefits. If the application is open-source, but does not have easy ways to add extensions, users will either settle for the out-of-the-box version or choose a more “flexible” solution. A similar situation is true for the dwm graphical shell. The description of the process of installing “extensions” for dwm (or more precisely, patches) turned out to be so complicated that it turned into a full-fledged article.

Easy update

A modular application consisting of plugins is much easier to update on the user side than a monolithic one. Technically, it comes down to simply adding or replacing one or more extension library files.

Since the plugins have little dependency on each other, any user can put together an application to his own taste, as from a constructor. In doing so, he gets only what he needs. Such a constructor application is almost impossible to implement without using plugins – you would have to have thousands of assemblies with all possible combinations of feature sets (or get an inconvenient patch system like in dwm).

Plugins – disadvantages

Higher complexity of implementation

The more flexible a system is, the harder it is to implement and maintain it. And this is true for all the stages of development – from designing to coding.

The task is really quite difficult. You can’t do without compromises. The difficulty is this: how to choose a plugin interface that simultaneously reveals everything you need while hiding everything else. So we move seamlessly to the next disadvantage.

Security issues

If you don’t limit plugins’ freedom of action, you can run into security problems. What plugins do is the responsibility of the developer and the application core designer. One must always keep in mind that an intruder can slip the user his own plugin under the guise of a “good” plugin. If the plugin is allowed to do anything, anything can happen, depending on the authorization level of the user who is running the application.

To solve this problem, you need to ensure that the privileges with which the plugin will work are lowered.

It is handy to take advantage of programming language security constructs. A good example is the Java language, which boasts many systems and levels of security.

Another option is to develop or use for plugins a special language with more limited features than the one in which the kernel is written (for example, in Qt in C++ you can look at QtScript). A real example of a successful use of this approach is the text editor Vim. It is itself written in C, but there is a special language Vim Script for creating extensions.

If you are extremely serious about the reputation of your product, you can go even further, and engage in rejection of “bad” plugins. Extension developers must pass a quality check, without which their plug-in will not be included in the official database. A similar decision is made in Apple’s App Store.

Conclusions

We can now give an answer to the next question: “When and what to put in plugins”. If you plan to update your application frequently, give your users freedom to choose the necessary set of features, make it relatively easy to add modules from third-party developers, then plugins are your choice.

But don’t forget that full-fledged plugin support is a big responsibility. You should worry in advance about the versatility, reliability and security of the plugin interface. If you are not too interested in the above benefits, it is much easier to limit yourself to usual dynamic (or static) libraries, which will obviously be linked in the process of building the project. In this way, you will simplify your task and significantly reduce the amount of work.

The post Plugins: Pros and Cons appeared first on InSaneProgramming.

Mistake #1. Too narrow a name of a class or interface

It is not always possible to predict the direction of the program and/or library. This can lead to the fact that the name of the class or interface is too narrow for its actual use.

The first variant of such a problem is that the name no longer corresponds to the inheritance hierarchy. For example, initially at the root of the hierarchy was the Camera interface. Then it turned out to be extremely convenient to implement a class for working with an electron telescope Telescope, inheriting this interface to be able to use the existing polymorphic code. But a telescope is not a camera, so it’s not a good idea to break logic.

Another form of this error has to do with extending the functionality of the class. The XMLHttpRequest class, included in the standard Javascript language library, immediately comes to mind. Actually it can work not only with XML data, but it’s not obvious from its name, which can be misleading.

Such error can be solved by means of refactoring or source code search/replacement operation. But there is one but. If you are developing not a self-sufficient project, but an application library, it can be very difficult to do, because other projects depend on your code. So you can’t just change the name (as in the case of XMLHttpRequest). In this case, you can rename the class, but for compatibility, create an alias that matches its old name. The old name should be marked as deprecated.

Mistake #2. Uncontrolled expansion of inheritance hierarchies

Inheritance is a useful and powerful programming technique. But you have to know the limits. If there is an entity in an application, it does not mean that there must necessarily be a class for it.

For example, if you develop a more or less complex game, there will be many entities: game character, enemies, obstacles, weapons, etc. If you create a class for each individual entity (e.g. sword, gun, rifle, etc.), the program will simply drown in hundreds or even thousands of similar classes.

The solution is to select a few basic classes that characterize the concepts: enemy, obstacle, weapon, etc. Next, the enemies themselves can be divided into ground enemies, flying enemies, etc., and given some typical characteristics (movement speed, size, attack power, etc.) in the form of class fields. Do the same for other entities as needed. For dynamic aspects of behavior (movement trajectory and artificial intelligence elements), use delegation, which is also useful for parameterizing the behavior of classes.

Mistake #3. Calling functions not by sense, but out of “convenience

Sometimes, when you are pressed for time to complete a project, you are tempted to cut and simplify something. This almost always leads to problems in the future.

For instance, you have a function that handles a button press. It performs a certain sequence of actions. Suddenly we notice that the same sequence of actions must be reproduced when a certain condition occurs in the program. It is hard to resist, and not to make a call to the handler directly. However, this leads to non-obvious dependencies that will turn into errors in the future if we need to change the handler code.

The correct solution in this situation is to create another function (or possibly more than one) that has a meaningful name and does what originally happened in the handler. Then this new function will be called in the handler and in all the places where it is needed. When the time comes to change something, if the changes are of a general nature, they can be made in the created function, otherwise they can be made individually on the spot, without affecting the logic of the rest of the code.

Mistake #4. Deliberate duplication of code fragments

Duplication in programming usually causes only troubles. But it is one thing when it happens by accident and another thing when the code is duplicated deliberately. Most developers face this problem. It seems sometimes that it is easier to copy a piece of code from one place and paste it into another than to allocate a separate function (or class), for which one still has to find a proper place, think up a good name and a successful signature. But this feeling is deceptive.

Very often it turns out that if some fragment had to be copied once, it will have to be copied again. The worst thing is when the developer himself realizes the depth of the problem, but can’t give up what he has started and uses “copy-paste” once again. Thus he drowns himself. For if it turns out later that the copied and pasted code contains an error and it must be corrected in every duplicated fragment, you will have “fun” hours of routine work with lots of potential errors.

The only right solution in this situation is not to be lazy and create auxiliary functions and classes in time. In the future, the time you have spent will pay off many times over, and you can avoid a lot of difficulties and problems. If you fail to do it in time, the refactoring tools can help you. In many IDEs, they are so smart that they can find duplicated functions by code fragments themselves.

Mistake #5. Inappropriate function and variable names

This error type overlaps in many aspects with errors 1 and 3, but I decided to mark it separately because there are conceptual differences between them.

We often give wrong names to functions and variables in haste. Sometimes this is due to an incomplete understanding of the subject area or design errors. But that’s no excuse.

Of course, there’s no need to be 100% pure either. In a simple for loop, it is fine to use variable i, but the larger the scope, the more meaningful the name must be.

Even worse, if the name is meaningful but misleading. That is, the name implies one thing, but in fact the variable stores something else; or the function does not do what you would expect it to do (for example, there are side effects).

The solution is to critically analyze the code, because in most cases a simple renaming is not enough. A bad variable or function name is often related to a design mistake, i.e. something is in the wrong place or does more than it should. So fixing the problem requires care and time. But it is worth it, because the clearer the code is, the less chance there is of errors appearing in it.

The post Five Typical Design and Programming Mistakes appeared first on InSaneProgramming.

If you want to succeed in programming, you must be able to:

• Find patterns and dependencies, reflecting them in the code structure. Sure, you can write long and convoluted code that will solve a problem. But keep in mind that good code must also be maintainable, that is, it must be UNDERSTANDING, which is achieved by selecting clear logical structures, whose meaning is obvious without explanations (comments);
• to classify entities in the form of classes and modules with consistent interfaces. Choosing the wrong base class can lead to serious problems in the future. For example, in a game application the architecture can be structured in such a way that a different class is created for each game object;
• clearly separate the application by abstraction levels. Decide on the structure of the application. Use encapsulation as intended. In a well-organized application, you can’t have SQL code sampling from a database next to GUI code. Consider applying patterns (e.g., MVC);
• Define algorithms in the form of procedures and functions. Avoid side-effects and unnecessary dependencies that are potential bugs. Be guided by the principle of single responsibility.

A few tips to help you develop abstract thinking:

• Read books about object-oriented design and analysis. A good starting point is Object-Oriented Analysis and Design;
• Spend time studying standard architectural solutions. There is no point in wasting your time and effort on tasks for which you already know reliable solutions. I recommend reading the books: Design Patterns and Object Oriented Design Techniques;
• take an interest in the architectural solutions adopted in other people’s successful projects. Just knowing the patterns is not enough. You need to be able to combine them correctly and effectively. Incorrect use of patterns will only worsen the code structure in most cases. Learn from other people’s examples drawn from open-source projects and articles on their own creations by the authors themselves. I recommend the book Perfect Architecture. Leading experts on the beauty of software architectures;
• More Practice. You will only get a sense of confidence in software development if you have experience. Solve a variety of problems and strive to experiment.

The post The Programmer’s Profession: Abstract Thinking appeared first on InSaneProgramming.

Rule 1: The later, the better

This rule seems to be the easiest to apply. After all, it encourages a reduction in workload. But that feeling is deceptive. Very often there is a temptation to optimize prematurely. As a result, the program structure becomes more complicated. It becomes more difficult to read it. As a consequence, the code becomes harder to maintain. But even this is not the worst thing. The problem is that you may waste a lot of time on optimizing the wrong code.

Conclusion: At the first stage of development, write the simplest code (simple, but not primitive! simple = understandable), which solves the task at hand without thinking about resource limitations.

Rule 2. Measurements first – then changes

Suppose the first stage is passed. A simple version of the program works properly, but not effectively enough. And here the question arises, how to measure effectiveness? There is no such thing as abstract efficiency. It is always determined relative to something. For example, efficiency with respect to memory consumption or efficiency with respect to the use of processor resources. This brings us to the next step: choose optimization criteria. Any relevant characteristic of an application can be considered as such criteria (from the size of an executable file to the speed of a network transfer).

On no account should you try to meet the criteria “by eye”. You will be wrong anyway. Find a way to measure accurately (or as closely as possible). For some characteristics this is easier (e.g. program size), for others it is more difficult (e.g. the maximum number of simultaneous users).

So you have made sure that the program does not meet one or more of the selected criteria. What now? Run to rewrite everything? Take your time. If you begin to change the code now, you will again work blindly and do a lot of unnecessary work. We know there is a problem somewhere. But where is it? Again we need additional tools for measurements. A typical solution is to use a profiler. The profiler itself is a tool that knows how to calculate the number of calls, time-to-find, and other useful numbers for each program procedure. The implementation of the profiler can be anything (much depends on the platform): from an external application to a library. If you find a more suitable tool for your purposes, use it.

Fine. Suppose we have managed to find the bottleneck that slows everything down. That’s what we need to work with.

Conclusion: any optimization must be reasonable. It is quite possible that it is not necessary. If you don’t measure it, you won’t know about it.

Rule 3. Check algorithms and data structures

When reviewing a problem function, first check whether the algorithms and data structures used to solve the problem are appropriate. This can be the reason for the ineffective work of the application.

A rough example: The function uses a linear array search. While this is fine for arrays of small size, it becomes a problem for large arrays. In this case, you can use a set instead of an array if you don’t want the elements to be ordered. Alternatively, instead of a simple linear search, you can try a binary search.

Another example: you use fast sorting, but it doesn’t work fast enough. See if it would improve if you changed it to merge or insert sorting. Quick sorting is not always the best.

Note that the examples discussed above are better not considered optimizations, but corrections of design flaws.

If the function in question already uses the most suitable standard algorithms and data structures, you can’t do without multithreading. I recommend to see a good example from my other article where we accelerated the image processing algorithm 4 times with QtConcurrent.

But this is not a complete list of possible optimizations. Often it is possible to reduce the amount of necessary calculations by introducing additional unobvious constraints. Think of the “Eratosthenes Lattice” algorithm for finding prime numbers. Another possible optimization is to use approximate calculations. If two decimal places are enough for you, there is no point in looking for a value up to the sixth. Another tactic is to use constant tables. For example, to get the values of trigonometric functions. I think you can think of more than one trick that can improve the efficiency of your program. It all depends on the context.

Conclusion: Start with the most obvious ways of optimization. Be sure to re-measure the performance of the new code (after any changes), otherwise how will you know that it is not even worse than it was? If that wasn’t enough, then navigate through the situation. Try to add parallel processing or approximate calculation methods.

Rule 4. Document it

If the optimization was successful, it is likely that the code you were working on became less comprehensible. This can be a problem in terms of further maintenance of the system. Therefore, right after the optimization is done, it won’t hurt to write a comment stating:

• The rationale for this code. That is, why the optimization was necessary. It is desirable to add the numerical values that you obtained as a result of measurements (before the optimization and after it);
• Explanation of the chosen solution. What is the essence of optimization. What makes it possible to increase the efficiency, etc;
• Indication of the options that you’ve had time to try, but they didn’t meet expectations. Perhaps someone else will be working on the same code and decide that it can be made even better. You’ll make your colleagues’ work easier if you share your experience with them in the comments, pointing out what has already been done so they don’t waste their time.

Conclusion: If the code is complex, it requires explanations. These explanations can help you in the future.

Rule 5. If nothing helped

But what to do if you have already tried everything you can, but the program still does not fit the criteria of optimality? Here you can have several options:

• Discuss the current version of the system with the customer. Perhaps a small discrepancy in terms of performance will suit him;
• Increasing the system requirements. If you cannot solve the problem programmatically, you can try to find a hardware solution. We put more memory, more processors, connect the Internet channel with more bandwidth;
• Switch to another (lower level) programming language. This does not mean that you need to rewrite the entire application. That is why we were looking for bottlenecks that require optimization. You only need to rewrite the problematic functions in a more efficient programming language in the form of plugins. For instance, the system is written in Java and you write the module in C++. Or the system is written in C++, and you do an assembler plug-in.

Conclusion: If a problem doesn’t have a solution at one level of abstraction, it can be found at another.

The post Five Rules of Program Optimization appeared first on InSaneProgramming.

The computer does not care about the quality of the architecture of the program system; the choice of names of classes, functions and variables; comments and other minutiae of life. The evolution of programming languages owes its evolution to limited human capabilities. For a machine, a language consisting of zeros and ones is quite understandable and natural (native) – binary code. Compared to the binary code, even the assembler seems a big step forward, because the human brain is not designed to memorize numbers.

Modern programming languages try to enable developers to model real objects in the form of abstract models. For example, it is much more convenient to manipulate a concept such as “image” rather than “array of pixels.

Remember that in most cases good code is code that is easy to understand (both for you and other people). There are exceptions, of course. In particular, there may be a need to optimize a program for speed of execution or memory consumption. However, premature optimization often seriously undermines the quality of your project. Remember: optimize only what is guaranteed to work. Code profiling will help you with this. Optimizing before you make any measurements is a waste of time at best. Without a performance gain assessment, you won’t even be able to say unequivocally that the code hasn’t become less optimal than it was before!

The reality is that software projects these days are on such a scale that at least a few developers are needed to achieve acceptable release dates. In this case, the importance of code quality becomes even higher. The way you think should be clear not only to you, but to the rest of the team as well. Try to suppress the desire to show off your erudition by using too complex structures and language constructions, if you can use a simpler analogue. Reading your code, others should get the feeling that it is simple. Simple in a good sense (not primitive). So simple that you can’t imagine it any other way. If you can do that, you’ve succeeded.

But don’t forget that there is a downside to collaborative development. You must be able to read other people’s code, and this can be more difficult than writing comprehensible code yourself. Of course, in a well-organized team, the architecture of the application should be such that each developer is assigned a set of system modules to work on. This avoids most version control conflicts when incompatible changes made by different programmers occur within the same file. But be prepared for the fact that at any time it is you who will have to pick up someone else’s modules. After all, no one is immune (anyone can fall on his head traffic light).

Agile development techniques welcome “pair programming” and “collective ownership of the code. Explore these techniques. Perhaps some of these will work for your development team.

Here are just a few books on the subject that I can’t help but mention, and highly recommend reading:

• Perfect Code. A Practical Guide to Software Development. A must for careful and thoughtful reading;
• Clean code: creating, analyzing and refactoring. WARNING. Propaganda of flexible software development methods
• Perfect Code. Good training in reading other people’s code, of which there is a lot in this book.

The post About the Program Code appeared first on InSaneProgramming.