"The best hacker and developer publication on the internet" — real person on Twitter. Submit your tech stories to Hacker Noon: hackernoon.com/signup

test7

Your domain’s reputation can make or break your business. A content website that’s meant to entice readers to subscribe to its RSS feed, follow on social media, or just generally consume what it serves on a daily basis and gets thousands or millions of followers is a success. An e-commerce site that manages to reach its intended monthly sales quota is also successful. And these scenarios are what all businesses with an online presence aim for. What they don’t want to do, meanwhile, is get hacked and put their company, employees, customers, partners, and other stakeholders at great risk. All that depends on how secure and reputable their domain is. That said, I compiled a list of must-dos for businesses, big or small, to help check website reputation and score high in any domain reputation API’s review process. 1. Keep your website content, related domains, and host configuration up to par If your website touts to be a provider of great content that readers can use as reference, then you have to make sure that it does just that. Your content must provide value; be accurate, relevant, search-optimized, and mobile device-friendly; and cater to your intended audience. Be sure no one has tampered with or defaced your site as well and that all pages are accessible or aren’t being . DDoSed Keeping a secure and reputable domain also means that all subdomains tied to it are free from . Make sure none of your domains have malicious ties nor redirect visitors to phishing and other malware-infected sites or pages. That said, when citing sites outside your domain as reference, see to it that the sites and pages are reputable and threat-free as well. Remember that your domain’s reputation will be affected by that of any site or page linked to it. If one of them is categorized as “malicious,” your site will be too. digital threats Finally, the has made it mandatory for all companies with an online presence to employ IT infrastructure hardening. Simply put, this means shielding servers, applications, OSs, and databases against all kinds of threats. This entails using strong passwords for all user accounts, limiting access to administrative accounts, keeping applications patched, and so on. Only by protecting the systems that host your domain and the applications that run them can you ensure that your domain maintains a high reputation score. ubiquity of cyber attacks 2. Use an SSL certificate to make sure all connections are secure A company needs to install an SSL certificate onto its web server to initiate secure sessions with browsers. Once a secure connection is established, all of the traffic between your web server and any web browser will be protected. A sure sign of this is that when accessed, your site name will no longer be preceded by HTTP, it will instead run on the HTTPS protocol. You can also see a lock icon beside its name, giving visitors the added assurance that they are in a safe space. 3. Make sure your domain doesn’t appear on any malware data feed One of the first things cybersecurity companies do to protect their customers is to block access to dangerous websites. Ensure that your domain isn’t hosting any , redirecting visitors to bad sites, serving up malicious ads, or isn’t being used to spam users, otherwise it may just end up in malware feeds. When that happens, no matter how good your content, product, or service offerings are, no one will ever see them. malicious software 4. Constantly update your WHOIS record The law requires all website owners to register their domains and maintain up-to-date WHOIS records that do not contain false information. This allows them to assure users of the Internet’s safety. Anyone caught providing untruths can have their domain ownership rights instantly revoked. Repeat offenders can even be banned from owning domains ever again. Note too that domain ownership rights expire. So keep track of your domain’s expiration date and be sure you never fail to renew before the deadline’s up. That way, your site will always be up and running and no one can snatch your domain name away as soon as your rights to it expire. 5. Maintain properly configured DNS MX records and mail servers DNS MX records are responsible for the proper delivery of email to your address. They tell users which mail servers accept incoming mail for your domain and where emails sent to your domain should be routed to. Your readers’ or customers’ emails should end up in your inbox and no one else’s. Keep cyber attackers from rerouting mail that’s meant for your eyes to their own specially crafted inboxes, thus putting your company, employees, customers, partners, and other stakeholders at risk of data loss or theft and other threats. 6. Safeguard your nameservers from harm Nameservers are simply applications that use a network service to provide responses to queries made to a directory service. In other words, they translate your domain name into an IP address that identifies the system that will answer a query. With threats like typosquatting, DDoS and DNS amplification attacks, registrar hijacking, cache poisoning, and more that can affect them, you need to constantly protect your nameservers so your visitors end up on your site and not on malicious ones created and maintained by ever-wily and eagerly waiting cybercriminals. 7. Ensure that none of your IP addresses are tagged “malicious” Cyber attackers are very technically adept and so can find ways to replicate your IP addresses so they can trick your supposed site visitors into ending up on phishing or other malware-laden sites of their own creation. That’s why cybersecurity solutions typically block user access to IP addresses that have ties to cybercrime or cyber attacks. If your IP address ends up being spoofed and thus blocked, then no one can visit it. Certain Web authorities, apart from cybersecurity professionals and law enforcement agencies, are always on the lookout for potentially harmful sites to block access to or protect Internet users from. They use domain reputation scoring tools to make sure no one ends up paying cybercriminals for fake or even nonexistent goods or services or giving out their personally identifiable information or PII, which often includes credit card details and other confidential data, to phishers and other threat actors. --- I’m pretty sure no company wants their domain to end up on a blacklist. One way to ensure your domain scores high (translation: doesn’t get flagged for malicious activities) on any domain reputation API, you must do all seven items I’ve listed above. These practices make up what good domain scoring tools rate domains against to gauge how safe they are for users to access. There are several or scoring tools available today but choose one that checks for all the elements I’ve listed to make sure your domain is threat-free. Only by doing a proactive check of your own domain can you be assured that your entire Web infrastructure maintains its good name. Like I said earlier, your domain’s reputation can make or break your business. Make sure your domain name spells success and not danger. Try using our own , which uses all seven aspects to keep your brand protected and safe from any online threat at all times. domain reputation APIs Domain Reputation API

The Domain Reputation API Test: 7 Must-Dos to Score High

India with its 1.43 billion people is now inarguably the most populous nation in the world.[1] Of these 68%[2] (or about 970 million people) are in the working age of 15 to 64 years of age. The unemployment rate stood at 6.6% in 2021-22.  As many as a whopping 42% of India’s graduates under 25 were unemployed in the same period.[3] Does the advent of AI-encompassing technologies like Generative AI threaten to inflate this number to catastrophic proportions? What does the future hold for India's unemployed millions (35 million in both 2021 and 2022)?[4] In a world of global uncertainties and changing power dynamics as well as realigning global supply chains, the state of the Indian economy and by extension its ability to provide gainful employment to millions of people of working age is an area of pressing concern. The rollout of AI in India is in its initial stages but has nevertheless significantly affected employment in some sectors on account of its ability to automate several routine tasks. At the same time, it has created new opportunities in AI-related job functions. According to CNBC outsourced coders based out of India are slated to lose their jobs in about two years.[5] That may sound worrisome, but on the other hand, a survey conducted by the leading job site Indeed found that Indian companies and employers hold a positive outlook on the impact of AI on jobs. As many as 85% of the Indian companies who participated in the survey believed that AI would impact the job scene positively in the short term (next 5 years).[6] This is borne out by the fact that the advent of AI has led to the creation of a whole host of opportunities in engineering, data science and machine learning, putting a huge premium on people possessing the required skill set. World Economic Forum assumes that AI will create 12 million more jobs for people than the ones it will displace. India is fortuitously placed to capitalize on it because it is home to 416000 AI professionals (August 2023) figures against a demand of about 629000 such people. This figure is likely to hit 1 million by 2026 if one goes by a report by the Wheebox National Employability Test.[7] Cause for anxiety The promise of availability of plentiful employment across the short-term horizon notwithstanding there is genuine anxiety amongst employees and job seekers in the country about the impact of AI on their future prospects. These pertain to the need for them to reskill or upskill to stay relevant. Then there is the ever-present gnawing fear of facing redundancy on account of the adoption of AI. For instance, the launch of Chat GPT in November 2022 made a whole host of professionals across the spectrum ranging from programmers and financial advisors to accountants and legal assistants fear for their jobs. People would naturally feel alarmed when leading financial institutions like Goldman Sachs anticipate AI impacting if not altogether eliminating as many as 300 million jobs.[8] Conclusion Viewed objectively, the adoption of AI by businesses in India will require some realignment regarding roles and the need for reskilling but will end up creating way more opportunities than any marginal displacements. It opens up huge opportunities for savvy entrepreneurs to leverage it to offer way better products and offer far more efficient services. Doing so will create more employment not just by way of AI professionals needing to be deployed, but also by creating whole new categories of products and services, that one can't even conceive of right now. When computers first arrived on the scene people thought that banks would stop hiring people, but the sector realigned itself and expanded like never before, giving rise to the fintech industry that is revolutionizing banking services in ways not thought possible in the past. The future is bound to be good for the youth of this country- Artificial Intelligence will ensure that it is so. [1] https://www.worldometers.info/world-population/india-population/ [2] [2] https://www.businesstoday.in/india-at-100/story/inclusive-india-2047-empowering-the-demographic-dividend-395359-2023-08-24 [3] https://indianexpress.com/article/business/42-3-of-graduates-under-25-unemployed-finds-latest-state-of-working-india-report-8949124/ [4] https://www.newindianexpress.com/web-only/2023/Jul/29/the-19-million-plus-question-has-finding-a-job-in-india-gotten-harder-or-easier-2599577.html [5] https://www.businesstoday.in/technology/news/story/ai-will-take-away-jobs-of-outsourced-coders-in-india-in-next-2-years-stability-ai-ceo-390384-2023-07-19 [6] https://economictimes.indiatimes.com/jobs/mid-career/ai-to-have-positive-short-term-impact-on-jobs-finds-global-survey/articleshow/104471561.cms?from=mdr [7] https://www.livemint.com/ai/artificial-intelligence/ai-in-india-jobs-evolved-not-erased-opportunity-and-reskilling-key-experts-claim-11703326684794.html [8] https://www.thehindu.com/sci-tech/technology/ai-anxiety-workers-fret-over-uncertain-future/article67157022.ece

The Impact of Artificial Intelligence on Employment in India

Answering the 10 Most Common Questions About Java

Unit testing is utilized to examine small segments of code that can be secluded logically in the system. Frameworks normally managed to do unit testing are . JUnit, NUnit, JMockit, PHPUnit, or tools like TestComplete The motive behind unit testing is to verify each software segment(unit)on the basis of expectation and the actual result we will get based on test cases. Unit testing is the initial measure of testing in the complete software development life cycle. Unit Testing is basically performed by developers who are developing their code in a secluded environment and other testing measures come when developer’s code merges to master or deploys to a higher environment. Unit Testing → Integration Testing → System Testing → Acceptance testing Unit testing in the beginning itself will be cost and time effective in the end. It assists to settle bugs timely in the software development cycle. It helps coders to recognize the code functionality very easily. The test cases defined, should be self-contained and it's like testing one piece at a time. Your code attitude should be like that more code you put lacking testing, more locations developers have to verify for bugs. Unit Testing can be done both Manually and Automation. But from the perspective of Software Engineering, automation testing is preferred.  We will see how we can integrate unit testing with Jenkins now. Doing unit testing in Jenkins - Freestyle Project Proceed Manage Jenkins → Manage Plugins, then Install JUnit Plugin Unit testing in Jenkins will be initiated after installing a unit testing plugin in Jenkins. This installation will enhance Jenkins' features for JUnit functionality. To notice the actual performance, let's observe it with a practical demo. We will examine it initially with freestyle projects. Click on “New Item” → Title the project and generate freestyle projects. During the configuration window, choose “Git” in “Source Code Management” section and supply all required details: Select “Invoke top-level Maven Targets” below the “Build Step” segment. (Note:- We are utilizing a maven project here for our example. Arrange and include the test step for the Goal text box. Let’s check each option Maven Version -- If you have multiple versions of , select one you preferred. Maven installed -- Maven goals, you want to incorporate with “mvn” command Goals -- place of pom.xml file. POM Now, once test records will be generated, we are required to execute some post measures on the basis of those records / reports. Pick “Publish JUnit test result report” below “Post-Build Actions” Path where your XML files(test reports) are kept. Location defined in this text box is relative to the root of your workspace. Test report XMLs -- If this choice is selected, output or failure from the test suite will be engaged in test results following the completion of build. This selection is essential uniquely when you desire to understand each and every log message in the console output of build but it will result in an increase in memory consumption of Jenkins. Not recommended Retain long standard output/error - This is like an amplification factor, utilized when calculating test records presenting to build health score. Suppose, for “1”(default value), it will measure like 10% of tests lacking with an overall 90% health score. Health report amplification factor - - If checkbox is selected, then it will change default actions of failing the build when there are misplaced or void test case files. It will not fail the build for any such structure, if and only if selected. Allow empty results Click Save & Build Verify the console output: Running com.java.AppTest 
Tests run: , : , : , : , Time elapsed: sec «<< FAILURE!
testApp(com.java.AppTest) Time elapsed: sec << 1 Failures 1 Errors 0 Skipped 0 0.029 0.002 < ! ( ) ( ) ( ) ( ) ( ) , , , FAILURE junit.framework.AssertionFailedError at junit. framework. Assert.fail Assert.java:47 at junit. framework. Assert.assertTrue Assert.java:20 at junit.framework. Assert. assertTrue Assert.java:27 at com.java. AppTest.testApp AppTest.java:36 Results: Failed tests: testApp com.java. AppTest Tests run: 1 Failures: 1 Errors: 6 Skipped: 0 , taken in this example, is a failed one, so that's why it broke the build. Improve your code so that your test case will be passed. Then Build again.  Build will be successful now and observe that Jenkins dashboard will also be updated. Test case Click on “Latest Test Result”. Build job will be initiating a test report in this link. You will verify the number of test cases executed and failed, if any: Similarly, you can observe a graph in your Jenkins job dashboard which will show you the course of test cases(failures/success) on the basis of jobs execution: Previous build failed because of 1 test case failed, 2nd passed (0 failed test case). From the color contrast, you can easily guess which one is failed and which is passed. If you observe links inline with the chart: (just show failures) -- It will reveal only the movement corresponding to build where test cases failed. Enlarge -- As the title suggests, It will enlarge the graph to the whole window. Unit Testing in Jenkins - Pipeline Job Now, we will test by adding unit testing steps in our pipeline. As most people don't want to proceed through thousands of lines of console output, the pipeline will issue a “junit” step to record and aggregate test results. JUnit will be defined in post step as build will be going through stages and following the completion it will produce the reports. Jenkinsfile “post” block will look like: post { 
always {
junit testResults: *** surefire-reports /target/ /*.xml', allowEmptyResults: false 
//cleanws() 
mail to: ‘ 	@gmail.com',
subject: "Build Job: ${currentBuild. fullDisplayName}", 
body: "This is ${env.BUILD_URL}"
}
} Click New Item → Name the project and choose pipeline(or Multibranch as both will be using Jenkinsfile only) job. Press OK Configuration page will be opened. Define in the normal way by providing Github Branch Source to read Jenkinsfile from with proper credentials to link to repository. Click Save and then do the build. Check Console Output: [Pipeline] { (Declarative: Post Actions)
[Pipeline] junit
Recording test results Test results will be recorded and you will observe a new link appear on the left side with “Test Result”. Click on that result link to capture records. It will convey you in similar way, we observed in freestyle project: Test result(Number of failed and passed tests) Catalog of whole tests executed: Package -- Time took to run Duration --- No. of tests crashed under that package Fail -- No. of tests Skipped Skip -- No. of tests passed Pass -- Number of total tests accomplished Total Similarly, you can dig into that package by clicking onto it to minute details from package to class to plain Test. In the right border of the “Test Result” segment, you will observe “ ”. Press the link, a graph will be appeared displaying history of test records: Took 1.7 sec And you can debug each build test plot and compare. Unit testing in Jenkins is executed by defining unit testing steps in Jenkinsfile with help of “junit” directive. Some organizations prefer to grab or store the artifacts for analyzing and investigating locally for any test failures. And for that we can utilize the “archive artifacts’ directive prior to “junit” step. Process of Unit testing with Jenkins document test results which help in to surface details from Jenkins dashboard to the team that includes higher management also and can assist in planning deliveries. More Options to do unit testing with Jenkins There are multiple unit plugins available relying on the framework you are utilizing or want to utilize. Most of them are: AUnit CUnit CppUnit EmbUnit FPCUnit MbUnit NUnit PHPUnit UnitTest++ xUnit.Net If somehow, in an organization different projects, using different unit tests framework but Jenkins instance is same then you can install “xUnit” plugin froom your Manage Plugins section and utilise different framework options provided by Jenkins. I will give you a small demo of using this too: Install xUnit Plugin, then you will see the “Publish xUnit Test results” option under “Post-build Actions”. After clicking “Add” in front of “Report Type”, you will get multiple options of Unit testing frameworks. Select as per your choice and proceed. I will select JUnit only. You can select multiple frameworks also in a single job (depending on the scenario). Thresholds section will give you the option to set the build status depending on the number specified in test cases. If I select “Failed Tests” It will mark the build as unstable or failure depending on if new or total number of failed tests exceed the threshold provided by you. “Advanced” option will give you to configure it to minute details: Click Save and Build, you will get your xUnit recording your test results and work in a similar way like it was done while working with plugin. It will give you more power and control to specify your build status also. jUnit Conclusion Now, to summarise this blog, we discussed unit testing in Jenkins and unit testing with Jenkins with different types of jobs. This will help us in achieving one of the most effective parts of our SDLC. Next, we will discuss more about notifications in Jenkins. Waiting for your feedback while testing the testing plugin. See you soon !!

Everything You Ever Wanted To Know About Unit Testing

Introduction: In this series I will outline the results of a comparison between five different CI/CD services, namely: CircleCI Gitlab Travis Buddy AWS CodePipeline For this comparison, I will use each service to run tests and deploy a Dockerised Node application to AWS Elastic Beanstalk. I will detail how to configure the  CI/CD process with each service and I will provide some performance statistics that compare the services. Test project and process: The repository hosting the project tested and deployed by the various services can be found here: . The application is a small Node/Express application that is Dockerised and has a single test. Clone this application and push it up to your own Github repository as we will use it frequently throughout this article. https://github.com/AndrewBestbier/ci-comparison-blog The process followed for the test for each service is as follows: Results: The results can be seen in the table below. I encourage you to follow the instructions to replicate these results yourself. A few notes: The configuration time is subjective as it depends on your familiarity with each tool. For transparency, I had setup pipelines with Buddy previously as you can see in my other blog posts. That said, the ability to setup pipelines visually drastically decreases the configuration time. The run times are from when I first ran these pipelines and can be seen in screenshots later on in this post. I welcome suggestions on how to improve my run times. The run times are all from using the default machines that these services provide. These can, of course, be configured and a pricing comparison is out of the scope of this article. From my use case, is the clear winner. As I am not a DevOps specialist, setting up CI/CD pipelines visually really appealed to me and I find that it was extremely easy to configure. Buddy also had the quickest but I suspect that people will soon make suggestions on how I can improve my existing pipelines. Buddy is, however, not as well known as the other services and you should therefore examine their offering carefully before using their service over their competitors. Buddy Run Time In second place I would recommend AWS CodePipeline as it was surprisingly easy to configure which has not always been my experience with AWS. CodePipeline is deeply integrated with other AWS services which made it immensely powerful. If you are already using AWS heavily, I would thoroughly recommend this service. I personally found that Gitlab was the hardest to use out of all services as it wasn’t as well documented. Travis and CircleCI were very well documented and, if I wasn’t using AWS or couldn’t use a smaller company like Buddy I would definitely consider these services. Please comment if you have any suggestions — I would love to regularly update this series of articles with further optimisations. If you disagree with my findings, please let me know. Finally, please try replicate these results yourself and share your experiences using these tools in your own company. Methodology: Creating AWS User: For this article, we will need to create an AWS User so that the CI/CD services can programatically access Elastic Beanstalk. Navigate to the IAM service in IAM: Click Users Click : Add user Name your user whatever you wish. In this example, I named mine and gave them before clicking . CIComparisonBlogUser Programmatic access Next We then need to add a policy for this user. Click and search for attach the policy and click Attach existing policies directly AWSElasticBeanstalkFullAccess, Next . Review your user and save the and in a secure location. These credentials will be used when setting up each CI service. Access key ID Secret access key Creating Elastic Beanstalk app: We will need to create an application on Elastic Beanstalk where all the services can deploy to. Navigate to AWS Elastic Beanstalk where you should see the following starter screen: Click : Get started Name your application (I named mine ), select as the platform and choose which we will use for now. Click and go make some coffee as it will take some time to spin up: CI Comparison Blog Docker Sample application Create application Click the provided to view the sample application: URL Creating Docker Hub Repository: The final step needed for all services is the creation of a Docker Hub repository. Head over to , log in and you should see the following splash screen: https://hub.docker.com/ Click and click : Repositories Create Repository Name your repository whatever you wish (I named mine ) and click ci-comparison-blog Create You should see your created repository. The key part to remember is your equivalent of : andrewbestbier/ci-comparison-blog Setting up a CircleCI Pipeline: To setup a CircleCI pipeline, head over to and click (You will need to Authorise CircleCI through Github) https://circleci.com/ Log in with Github . Next click and and find your Github repository (mine is called ) before clicking the on the right: Settings Projects ci-comparison-blog settings cog Click and add your AWS and Docker Hub credentials ( , , and ). These will be used later on: Environment variables AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY DOCKER_USER DOCKER_PASS Next click on the sidebar, search for your Github repository and click : Add Projects Set Up Project You will then see a screen providing instructions on how to set your project up. The most important instruction is “Create a folder named .circleci and add a file config.yml ”. If you look at our Github repository, you can see that I have already created this file: version: 2 jobs: test: working_directory: ~/app docker: - image: circleci/node:latest # (1) steps: - checkout - run: name: Update npm command: 'sudo npm install -g npm@latest' - restore_cache: # (2) key: dependency-cache-{{ checksum "package-lock.json" }} - run: name: Install npm dependencies command: npm install - save_cache: key: dependency-cache-{{ checksum "package-lock.json" }} paths: - ./node_modules - run: name: Run tests # (3) command: 'npm run test' docker-deploy-image: working_directory: ~/app machine: docker_layer_caching: true # (4) steps: - checkout - run: | # (5)  
          docker build -t andrewbestbier/ci-comparison-blog .  
          docker login -u $DOCKER_USER -p $DOCKER_PASS
          docker push andrewbestbier/ci-comparison-blog deploy-aws: working_directory: ~/app docker: - image: circleci/python:latest steps: - checkout - run: # (6) name: Installing deployment dependencies working_directory: / command: 'sudo pip install awsebcli --upgrade' - run: # (7) name: Deploying application to Elastic Beanstalk command: eb deploy workflows: version: 2 build-test-and-deploy: jobs: - test - docker-deploy-image: requires: - test - deploy-aws: requires: - docker-deploy-image Let’s break down what’s happening during this build’s execution: The first job, test is run with a Node Docker container The are restored if they exist in the cache, otherwise they are installed node_modules The tests are run Docker layer caching is enabled to speed up image building performance ( ) https://circleci.com/docs/2.0/glossary/#docker-layer-caching Next, the Docker image is built and pushed to Docker Hub with the and environment variables. Remember to change the repository to the one you created. DOCKER_USER DOCKER_PASS The Elastic Beanstalk CLI tool is installed The CLI is used to deploy the app to Elastic Beanstalk with eb deploy . This command works as we have already been authenticated invisibly by CircleCI with the , environment variables. AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY You may be wondering, how does eb deploy know where to deploy to? To specify a location, you will need to modify the .elasticbeanstalk/config.yml file in your Github repository to align with the sample Elastic Beanstalk application you created: branch-defaults: master: environment: CiComparisonBlog-env environment-defaults: CiComparisonBlog-env: branch: null repository: null global: application_name: CI Comparison Blog default_ec2_keyname: null default_platform: arn:aws:elasticbeanstalk:eu-west-2::platform/Docker running on 64 bit Amazon Linux/2.12.17 default_region: eu-west-2 include_git_submodules: true instance_profile: null platform_name: null platform_version: null profile: null sc: git workspace_type: Application To find your equivalent values, see the following screenshot and the AWS documentation here: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html We are finally ready to go so click in the CircleCI dashboard and, with a little luck, your project should test, build and deploy successfully: Start Building Gitlab: First, head over to and sign in https://about.gitlab.com/ If this is your first time using Gitlab, you will see the following screen. Click : Create a project Next click the tab and connect to . CI/CD for external repo Github You will be prompted for a personal access token from Github with access. To do so follow this short guide: repo https://help.github.com/en/enterprise/2.17/user/articles/creating-a-personal-access-token-for-the-command-line Next, connect your repository: You should then see a dashboard with your project details: The next step is to add the environment variables. Click on the side bar and then click on the popup. Settings CI/CD Scroll down and add your AWS and Docker Hub credentials ( , , and ). AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY DOCKER_USER DOCKER_PASS The next step is to .gitlab-ci.ymlfile to the root of your directory. If you look in the Github repository, you will see the following file: image: node:latest # (1) stages: - build - test - docker-deploy-image - aws-deploy cache: paths: - node_modules/ # (2) install_dependencies: stage: build script: - npm install # (3) artifacts: paths: - node_modules/ testing: stage: test script: npm test # (4) docker-deploy-image: stage: docker-deploy-image image: docker:dind services: - docker: dind script: - echo "$DOCKER_PASS" | docker login -u "$DOCKER_USER" --password-stdin # (5)
    - docker build -t andrewbestbier/ci-comparison-blog .
    - docker push andrewbestbier/ci-comparison-blog aws-deploy: image: 'python:latest' stage: aws-deploy before_script: - 'pip install awsebcli --upgrade' # (6) script: - eb deploy CiComparisonBlog-env Let’s break down what’s happening during this build’s execution: The base image is a Node Docker container The cached node_modules The packages are installed The tests are run Next, the Docker image is built and pushed to Docker Hub with the and environment variables. Remember to change the repository to the one you created. DOCKER_USER DOCKER_PASS The Elastic Beanstalk CLI tool is installed The CLI is used to deploy the app to Elastic Beanstalk with eb deploy . This command works as we have already been authenticated invisibly by Gitlab with the , environment variables. Note how we have to specify the environment name in this command. AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY We are finally ready to go so push up a small irrelevant commit and, with a little luck, your project should test, build and deploy successfully: Travis CI: First, head over to and : https://travis-ci.com Sign in with Github You should then see a dashboard showing your connected projects. I have blocked out other personal projects I have. Click the small button to add a new project: + Next, search for your Github repository and click the button: Settings Scroll down and, like the other services, add your AWS and Docker Hub credentials ( , , and ). AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY DOCKER_USER DOCKER_PASS The next step is to .travis.yml file to the root of your directory. If you look in the Github repository, you will see the following file: language: node_js # (1) node_js: - 'node' services: - docker # (2) jobs: include: - stage: test script: - npm install # (3) - npm test # (4) - stage: docker-deploy-image # (5) script: - echo "$DOCKER_PASS" | docker login -u "$DOCKER_USER" --password-stdin 
        - docker build -t andrewbestbier/ci-comparison-blog .
        - docker push andrewbestbier/ci-comparison-blog - stage: deploy script: skip deploy: # (6) provider: elasticbeanstalk access_key_id: $AWS_ACCESS_KEY_ID secret_access_key: $AWS_SECRET_ACCESS_KEY region: 'eu-west-2' app: 'CI Comparison Blog' env: 'CiComparisonBlog-env' bucket_name: 'elasticbeanstalk-eu-west-2-094505317841' bucket_path: 'CI Comparison Blog' Let’s break down what’s happening during this build’s execution: The base image is a Node Docker container The docker service is used so that docker commands can later be used The packages are installed (Travis caches npm modules by default) The tests are run Next, the Docker image is built and pushed to Docker Hub with the and environment variables. DOCKER_USER DOCKER_PASS This step is quite different to other services as Travis offers its own Elastic Beanstalk deployment method (rather than using the CLI). One simply needs to specify the Elastic Beanstalk configuration details in the format Travis specifies and they take care of the rest. We are finally ready to go so push up a small irrelevant commit and, with a little luck, your project should test, build and deploy successfully: Buddy Head over to Buddy and sign in with Github. Then click : Create new project should intelligently work out that our project is an Express application. Click : Buddy Add a new pipeline Specify a pipeline name (I picked ), select trigger and click . CI Blog Post On push Add a new pipeline We can then create a first action to install our dependencies and run the tests. Search for the action and click it. Node.js You are then prompted for some bash commands to run. In our case we wish to run yarn install and yarn test . Then click : Add this action Next we want to build a Docker image from our source code. Search for the action: Build Image Buddy automatically detects your Dockerfile so just click : Add this action Next we want to push the image we just build up to Docker Hub. Search for the action: Push Image automatically uses the image built in the previous action. Provide your Docker Hub , , and before clicking : Buddy username password repository tags Add this action Finally, we want to deploy our files to so search for this action: Elastic Beanstalk A modal will appear requesting your AWS user and : Access Key Secret Access Key Select the AWS Region and your application should automatically appear. Then click : Add this action Your pipeline should look like this: Click and it should test, build and deploy your application successfully: Run pipeline If you wish, you can also set up this pipeline with a buddy.yml file in your root directory: - pipeline: "CI Blog Post" trigger_mode: "ON_EVERY_PUSH" ref_name: "master" ref_type: "BRANCH" trigger_condition: "ALWAYS" actions: - action: "Execute: yarn test" type: "BUILD" working_directory: "/buddy/ci-comparison-blog" docker_image_name: "library/node" docker_image_tag: "10" execute_commands: - "yarn install" - "yarn test" setup_commands: - "npm install -g gulp grunt-cli" mount_filesystem_path: "/buddy/ci-comparison-blog" shell: "BASH" trigger_condition: "ALWAYS" - action: "Build Docker image" type: "DOCKERFILE" dockerfile_path: "Dockerfile" trigger_condition: "ALWAYS" - action: "Push Docker image" type: "DOCKER_PUSH" login: "andrewbestbier" password: "secure!KmF0va9L3z4s450LWVlvNdHi1+6Z6+45vQbkHS4bWFo=" docker_image_tag: "latest" repository: "andrewbestbier/ci-comparison-blog" trigger_condition: "ALWAYS" - action: "Upload files to Elastic Beanstalk/CI Comparison Blog" type: "ELASTIC_BEANSTALK" application_name: "CI Comparison Blog" environment: "e-zpfbesiqpa" environment_name: "CiComparisonBlog-env" region: "eu-west-2" trigger_condition: "ALWAYS" integration_id: 65587 AWS CodePipeline: Login to AWS and navigate to the service. Next click : CodePipeline Create pipeline Next name your pipeline (I named mine ) before clicking : CI-comparison Next Next you will need to add a pipeline source. Select Github, follow the login prompts, connect your repository, select the master branch and click : Next We then need to add a build stage. Select AWS CodeBuild as a build provider and click . This will open a new tab where you configure the build. Create project Name your build (I named mine ) and scroll down the page. CI-comparison Select Managed image, Ubuntu operating system, Standard runtime, and the 2.0 image. Also enable the Privileged flag as we wish to build Docker images before scrolling down further: Next add the and environment variables DOCKER_USER DOCKER_PASS Select use file as we will be using a buildspec.yml file in our repositories root directory to specify the build steps. Finally click . buildspec Continue to CodePipeline The tab will close and you will be taken back to your CodePipeline configuration. Click : Next Finally, we need to add a deploy stage. Select as the deploy provider and find your application before clicking : AWS Elastic Beanstalk Next Review your pipeline and click : Create pipeline Now view the file in the root of our directory: buildspec.yml version: 0.2 phases: install: runtime-versions: nodejs: 10 # (1) commands: - echo "$DOCKER_PASS" | docker login -u "$DOCKER_USER" --password-stdin  # (2) pre_build: commands: - npm install # (3) - npm test # (4) build: commands: - docker build -t andrewbestbier/ci-comparison-blog . # (5) post_build: commands: - docker push andrewbestbier/ci-comparison-blog Let’s break down what’s happening during this build’s execution: The Node version is specified The build logs into our docker account with the environment variables The packages are installed The tests are run Next, the Docker image is built and pushed to Docker Hub Finally, click and it should test, build and deploy your application successfully Release change (Image Source: ) https://www.infostretch.com/resources/white-papers/continuous-integration-and-delivery/

The Results Of A Comparison Between Five CI/CD Services

7 secrets of writing successful microcopy in 2018 will be introduced here for you to enhance UX in your web/mobile app designs. In these days, besides rich functions, the words/texts (also professionally called “ ”) of a web/app contribute a lot to improving user experience. Any word, label or sentence on an app/web interface always matters. That’s why a growing number of companies start to and let them specialize in text/microcopy design/research to enhance UX. Microcopy hire UX writers As a UX designer or UX writer, you’ve already realized the importance of words or witnessed the magic of microcopy, but, don’t know how to make your microcopy outstanding and successful? Or really want to know some practical principles/guidelines to write short, clear, informative and enticing microcopy for better user experience, higher conversation rates and product sales? To help you out, we’d love to share : 7 secrets of writing successful microcopy for you to improve UX First, what is microcopy? Before we start to learn the tips of making an outstanding microcopy, you should firstly know what microcopy really is. Generally speaking, the microcopy of a web/mobile app often indicates a cluster of words/texts/copies on a page to instruct and alleviate the concerns of users. It often includes the labels of a button or option, privacy and security notes, terms and conditions, warning notifications and more instructions shown on your apps. So, in this aspect, it is indispensable for users to understand, learn and master a web/mobile app. Why is microcopy so important? Cannot help asking how come a small bit of words could be so important for a web/mobile app? OK! The answer is simple. A short, clear, informative and enticing microcopy helps designers improve user experience, increase conversion rates, sometimes even impresses users and let them remember the apps/products/brands clearly. To be more specific, microcopy often plays various roles in a web/app: 1). Consulter In daily use, people can easily check some instruction texts, such as the product/app instructions, privacy and security notes, terms and conditions, feature introductions, etc., to remove their usage problems and doubts. So, in this aspect, the app/web microcopy works as a consulter and help people use the app/web easier and faster. 2). Guider Many app texts, such as the labels of a button, the words showing how to sign in/up or other guidelines, often deliver useful information and lead users to complete a task/operation with ease. So, in this aspect, microcopy is also used as a useful guider. Microcopy can guide you to sign in successfully. 3). Comforter As we know, warning, prompt or error messages are indispensable for a web/mobile app. And an error message with well-crafted microcopy not only comforts users, removes their worries/doubts and also reduces frustration/negative emotions of them effectively. So, microcopy is also the very front comforter when users have some worries, doubts or problems while using an app/web. 4). Promoter And some labels of CTA buttons, product instructions or feature descriptions, also introduce a product clearly, impress user and entice them to purchase. So, in this aspect, microcopy is also an excellent product promoter. Microcopy can also introduce product/app features and stimulate users to purchase. In a word, an outstanding and enticing microcopy always contributes a lot to enhancing UX, increasing product sales and standing out an app. How can you make your microcopy outstanding and appealing for better UX as a UX designer/writer? Here are 7 secrets and best microcopy examples (some of them are made by an easier, faster and smarter prototyping tool, ) for you to learn: Microcopy is so important to enhance UX and competitiveness of a web/mobile app. Mockplus 1. Keep your microcopy simple and short Nowadays, texts in an app/web are increasingly important to guide users and achieve interaction with users. However, that does not mean the longer your microcopy is, the greater it will impact on users. Honestly, most users do not really read all shown words literally as you wish. Hence, in order to increase the chances that users will read them or understand the meanings behind quickly even at a glance, it is always better to keep your microcopy simple and short. For example, you can try to simplify your microcopy with the following methods: *Make your microcopy short and light To improve the user experience with excellent microcopy, the first thing you are supposed to do is to shorten and lighten your interface texts. Moreover, the best way is to write all contents down, and then, appropriately integrate, delete and replace some words based on different needs and scenarios. And at last, shorten your microcopy to the best state. Shorten and lighten your words to make them simple and intuitive. *Use lists or subtitles When the interface words cannot be shortened any longer, it is better to use lists or subtitles to simplify your microcopy. In comparison with the whole paragraph in Picture 1, the microcopy with lists in picture 2 and the text with subtitles in picture 3 are far more intuitive and easier for users to understand the actual meanings of them quickly. *Add links to simplify your microcopy The microcopy of a web/mobile app does not have to include all contents. In actual designs, you can easily add links (this is also called “ ” design technique that is widely used by UX/UI designers) to simplify your texts. The users can easily click the linked words to jump to other pages and read more details. Progressive Disclosure Add links to make your microcopy short and light. Please Note: Never make your text too light Simplifying your microcopy does not mean to blindly reduce the text words. Oppositely, your microcopy is supposed to deliver the most informative and complete contents with the least numbers of words. So, shorten your microcopy and also make it clear to avoid any ambiguous or incomprehensible situations. 2. Optimize your microcopy in combination with product/app/brand features While designing your microcopy, you are also supposed to combine the product/app/brand features to make it unique. Moreover, this will also be an effective way to increase the popularity of the product/app/brand. For example, in your design, you can try to add some words/sentences to introduce the special services/features of your products/apps, use special terms/phrases or choose special styles, color schemes or interactions based on product/app/brand features, etc. These ways always work to impress users and make them remember the product/app/brand well. Design your microcopy in combination with product/app/brand features. 3. Customize your microcopy based on different scenarios Microcopy works a lot to enhance UX of a web/mobile app. And you do not have to design every interface text with the same standards. Actually, it is often better for you to customize your microcopy based on different scenarios. For example, if you want to design excellent labels for CTA buttons, except making them simple and light, in order to get higher click rate, it is better to make them distinctive and enticing by adding smart and eye-catching interactions.(Click to check ) 10 common mistakes when designers create website buttons Add proper interactions to make your buttons eye-catching and entice more users to click. When it comes to some error or warning messages, it is also highly recommended for you to use some humanistic expressions to reduce frustration of users and improve user experience. ( ) Click to check 14 most creative 404 error page designs Add humanistic expressions to achieve emotional interactions with users. And as with some information interfaces that need users to fill some personal information, including “Sign In”, “Sign Up”, “Contact” or “User Profile” pages of a web/app, you’d better add some words/sentences to remove doubts/worries of users. Microcopy helps remove doubts/worries of users and encourage them to sign up safely. 4. Make your microcopy different Microcopy is not supposed to be designed in the same way. Instead, it should be regarded as an important platform to show your personality and creativity. Hence, you can try to make your microcopy different in the following aspects: *Improve your microcopy with imagination You can also improve your microcopy with imaginations. For example, It is usually a good try to use your microcopy to tell a story, illustrate the culture of a product/enterprise or present a special local/ethnic feature, etc. This can make your microcopy far more attractive. Use microcopy to tell an interesting story. *Make your microcopy different with humor Humorous or funny words/expressions/jokes not only attract users effectively, but also enable users to know/learn something more naturally and enjoyably. Use humor to improve your microcopy. Please Note: Be careful with funny jokes/humorous texts Humor is not suitable for all cases. Why? A humorous microcopy can make it easier for users to accept the sudden error or warning messages. While, it will also make a privacy and security note less convincing. Hence, you are supposed to be careful with funny jokes or humorous texts. *Pair your microcopy with photos As the old saying goes, “a picture speaks a thousand words”. In order to make your microcopy outstanding and convincing, you can also try to use words and photos together. Use photos to illustrate your microcopy more intuitively. And in such situations, to add some texts with photos, you can try to download and use Mockplus, which allows users to easily pair their texts with photos by using “Image” and “Label”/“Text Area” components together. Moreover, it also offers easier and faster solutions for designers to add dynamic photos, or static photos in batches. Of course, if necessary, you can also use its “ ” feature to add such “text + photo” pairs in batches with simple clicks. import Sketch Repeater *Show your unique style in microcopy designs Each designer has his own design style/tone to make a microcopy for a web/mobile app. In your design, you’d better show your unique design style/tone to make your microcopy unique and distinctive. This is a really useful way to attract and impress users. In a word, the microcopy designs created with creativity and sincerity of designers is doomed to be different and appealing to users. 5. Improve your microcopy with visual elements Except making your microcopy simple and different, you are also supposed to improve it with some visual elements. The visual elements, such as colors, fonts, sizes and interactions of the interface texts, are always attractive for users. Here are several clues for you to improve your microcopy in visualized ways: *Adjust the properties of texts to present its hierarchy/importance relations Many properties of the interface microcopy can be used to present its hierarchy/importance relations, such as the colors, fonts, sizes, background photos/colors and more. Moreover, strong contrasts of these mentioned properties could also work much better. In short, set, adjust or contrast the properties of your microcopy to show its hierarchy/importance relations. This is also helpful to make it easier for users to get the useful information quickly. In addition, while using Mockplus, , you can freely adjust or contrast the properties of an interface text easily by using its “Label” or “Text Area” components. a powerful prototyping tool *Add proper interactions or animations for your microcopy Smart interactions or animations can make your microcopy interesting and enticing. So, add proper interactions/animations to your microcopy for more pleasant user experience. Take Mockplus as an example. You can easily add loading, clicking, long clicking and more (especially the ) with simple drag-and-drop. interaction effects hovering effects It also offers many powerful interaction commands to enrich your microcopy designs, such as “Show/Hide”, “Move”, “Zoom”, “Rotate”, “Resize”, “Set Color”, “Set Text”, “Set Text Color” and more. In short, proper interactions are also effective for you to make your microcopy different in a visualized way. 6. Keep your microcopy consistent To help users understand and master your web/mobile apps easily, it is better to keep all interface texts consistent. And the consistency of your microcopy can be reflected in following aspects: *Use consistent appellations Muddled appellations in an interface text often make the entire microcopy complicated and confuse the readers. Hence, you’d better use consistent appellations in your microcopy designs. Please Note: Use “You” instead of “He”, “She”, “It” or “They” Moreover, in comparison with using “He”, “She”, “It” or “They” in your designs, “You” is often more acceptable for readers and helps you communicate with them more naturally. *Use consistent tenses In your text designs, it is highly recommended to use consistent tenses. Moreover, the active voice is much better to arouse users’ resonance than the passive voice. It is just like having a direct talk with them. Overall, keep your microcopy consistent in tenses. *Keep your words consistent In comparison with using completely new, ambiguous or obscure words/terms, directly reusing the words that you’ve used before in your microcopy designs is more acceptable and understandable for users. So, keep your words consistent. *Use consistent themes and color schemes The themes and color schemes of your microcopy also should be in accordance with the themes and colors of your entire web/mobile apps. *Use consistent design style/tone Each UX writer/designer writes their microcopy with a unique style/tone. That’s normal. However, in case of any messy situations, it is better to keep your design style/tone consistent in your actual designs. No matter which design style/tone you choose, such as simple, humorous, formal or informal design style or tone, always keep it consistent in the entire web/app design. Keep your microcopy consistent in color schemes, theme and design style. In addition, in this aspect, in order to keep your microcopy consistent easily, Mockplus with powerful , component and is really worth trying. Component Style icon libraries Take its Component Style library as an example, you can freely save, reuse and share the styles (such as colors, text fonts, sizes, alignment, etc) of your used components to keep your microcopy consistent in colors, theme, style or more. 7.Test and iterate your microcopy in an app prototype Like other elements of a web/mobile app, microcopy is also supposed to be tested and edited in a real app prototype over and over again. To be more specific, you’d better test and adjust the length, color, alignment, size, font, style and interaction of your microcopy in a real app prototype to see whether it works as you wish. And in this aspect, we have to mention Mockplus again for its . With these 8 ways, you can easily test the feasibility of your microcopy designs, and also collect feedback from users and designers to iterate your designs quickly. So, Mockplus is really an excellent prototyping tool for you to optimize your microcopy with ease and efficiency. 8 ways to test and share prototypes In a word, a creative and appealing microcopy not only improves user experience, but also enhance the competitiveness of your web/mobile apps easily. So, you’d better always pay much attention to the microcopy designs of your apps. Wrap Up The microcopy designs of an app/web play a really important role in improving user experience. However, they can work well as you wish only when you put it back to a real web/app or prototype. Therefore, in order to improve UX and enhance the competitiveness of your app/web, you’d better also pay more attention to strengthening and enriching the features and functions of your app/web. Of course, a right prototyping tool, like Mockplus, is also your best choice to make, test and iterate your app/web designs. Overall, it is always good for you to take every detail seriously in your app/web designs. Hope this article with 7 secrets of writing successful microcopy will be helpful for you to work out an outstanding microcopy.

7 Secrets to Write Successful Microcopy for Better UX in 2018

Writing a Blog Engine in Phoenix and Elixir: Part 4, Adding Roles to our Controllers

Debugging is not just about identifying errors—it's about instituting a reliable process for ensuring software health and longevity. In this post, we discuss the role of software testing in debugging, including foundational concepts and how they converge to improve software quality. https://www.youtube.com/watch?v=yap509UZz6M&embedable=true As a side note, if you like the content of this and the other posts in this series, check out my Debugging book, which covers this subject. If you have friends who are learning to code, I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while, check out my Java 8 to 21 book. The Intersection of Debugging and Testing Debugging and testing play distinct roles in software development. Debugging is the targeted process of identifying and fixing known bugs. Testing, on the other hand, encompasses an adjacent scope, identifying unknown issues by validating expected software behavior across a variety of scenarios. Both are a part of the debug fix cycle, which is a core concept in debugging. Before we cover the cycle, we should first make sure we're aligned with the basic terminology. Unit Tests Unit tests are tightly linked to debugging efforts, focusing on isolated parts of the application—typically individual functions or methods. Their purpose is to validate that each unit operates correctly in isolation, making them a swift and efficient tool in the debugging arsenal. These tests are characterized by their speed and consistency, enabling developers to run them frequently, sometimes even automatically, as code is written within the IDE. Since software is so tightly bound, it is nearly impossible to compose unit tests without extensive mocking. Mocking involves substituting a genuine component with a stand-in that returns predefined results, thus a test method can simulate scenarios without relying on the actual object. This is a powerful yet controversial tool. By using mocking, we're, in effect, creating a synthetic environment that might misrepresent the real world. We're reducing the scope of the test, which might perpetuate some bugs. Integration Tests Opposite to unit tests, integration tests examine the interactions between multiple units, providing a more comprehensive picture of the system's health. While they cover broader scenarios, their setup can be more complex due to the interactions involved. However, they are crucial in catching bugs that arise from the interplay between different software components. In general, mocking can be used in integration tests, but it is discouraged. They take longer to run and are sometimes harder to set up. However, many developers (myself included) would argue that they are the only benchmark for quality. Most bugs express themselves in the seams between the modules and integration tests are better at detecting that. Since they are far more important, some developers would argue that unit tests are unnecessary. This isn't true; unit test failures are much easier to read and understand. Since they are faster, we can run them during development and even while typing. In that sense, the balance between the two approaches is the important part. Coverage Coverage is a metric that helps quantify the effectiveness of testing by indicating the proportion of code exercised by tests. It helps identify potential areas of the code that have not been tested, which could harbor undetected bugs. However, striving for 100% coverage can be a case of diminishing returns; the focus should remain on the quality and relevance of the tests rather than the metric itself. In my experience, chasing high coverage numbers often results in bad test practices that persist in problems. It is my opinion that unit tests should be excluded from coverage metrics due to the importance of integration tests to overall quality. To get a sense of quality coverage, we should focus on integration and end-to-end tests. The Debug-Fix Cycle The debug-fix cycle is a structured approach that integrates testing into the debugging process. The stages include identifying the bug, creating a test that reproduces the bug, fixing the bug, verifying the fix with the test, and finally, running the application to ensure the fix works in the live environment. This cycle emphasizes the importance of testing in not only identifying but also in preventing the recurrence of bugs. Notice that this is a simplified version of the cycle with a focus on the testing aspect only. The full cycle includes a discussion of the issue tracking and versioning as part of the whole process. I discuss this more in-depth in other posts in the series and my book. Composing Tests with Debuggers A powerful feature of using debuggers in test composition is their ability to "jump to line" or "set value." Developers can effectively reset the execution to a point before the test and rerun it with different conditions without recompiling or rerunning the entire suite. This iterative process is invaluable for achieving desired test constraints and improves the quality of unit tests by refining the input parameters and expected outcomes. Increasing test coverage is about more than hitting a percentage; it's about ensuring that tests are meaningful and that they contribute to software quality. A debugger can significantly assist in this by identifying untested paths. When a test coverage tool highlights lines or conditions not reached by current tests, the debugger can be used to force execution down those paths. This helps in crafting additional tests that cover missed scenarios, ensuring that the coverage metric is not just a number but a true reflection of the software's tested state. In this case, you will notice that the next line in the body is a rejectValue call, which will throw an exception. I don’t want an exception thrown as I still want to test all the permutations of the method. I can drag the execution pointer (arrow on the left) and place it back at the start of the method. Test-Driven Development How does all of this fit with disciplines like Test-Driven Development (TDD)? It doesn't fit well. Before we get into that, let's revisit the basics of TDD. Weak TDD typically means just writing tests before writing the code. Strong TDD involves a red-green-refactor cycle: Red: Write a test that fails because the feature it tests isn't implemented yet.


Green: Write the minimum amount of code necessary to make the test pass.


Refactor: Clean up the code while ensuring that tests continue to pass. This rigorous cycle guarantees that new code is continually tested and refactored, reducing the likelihood of complex bugs. It also means that when bugs do appear, they are often easier to isolate and fix due to the modular and well-tested nature of the codebase. At least, that's the theory. https://www.youtube.com/watch?v=yImkjlm08Cw&embedable=true TDD can be especially advantageous for scripting and loosely typed languages. In environments lacking the rigid structure of compilers and linters, TDD steps in to provide the necessary checks that would otherwise be performed during compilation in statically typed languages. It becomes a crucial substitute for compiler/linter checks, ensuring that type and logic errors are caught early. In real-world application development, TDD's utility is nuanced. While it encourages thorough testing and upfront design, it can sometimes hinder the natural flow of development, especially in complex systems that evolve through numerous iterations. The requirement for 100% test coverage can lead to an unnecessary focus on fulfilling metrics rather than writing meaningful tests. The biggest problem in TDD is its focus on unit testing. TDD is impractical with integration tests as the process would take too long. But as we determined at the start of this post, integration tests are the true benchmark for quality. In that test, TDD is a methodology that provides great quality for arbitrary tests, but not necessarily great quality for the final product. You might have the best cog in the world, but if it doesn't fit well into the machine, then it isn't great. Final Word Debugging is a tool that not only fixes bugs but also actively aids in crafting tests that bolster software quality. By utilizing debuggers in test composition and increasing coverage, developers can create a suite of tests that not only identifies existing issues but also guards against future ones, thus ensuring the delivery of reliable, high-quality software. Debugging lets us increase coverage and verify edge cases effectively. It's part of a standardized process for issue resolution that's critical for reliability and prevents regressions. Debugging is not just about identifying errors—it's about instituting a reliable process for ensuring software health and longevity. In this post, we discuss the role of software testing in debugging , including foundational concepts and how they converge to improve software quality. debugging https://www.youtube.com/watch?v=yap509UZz6M&embedable=true https://www.youtube.com/watch?v=yap509UZz6M&embedable=true As a side note, if you like the content of this and the other posts in this series, check out my Debugging book, which covers t his subject. If you have friends who are learning to code, I'd appreciate a reference to my Java Basics book. If you want to get back to Java after a while, check out my Java 8 to 21 book . Debugging book , Debugging book t Java Basics book. Java Basics book. Java 8 to 21 book Java 8 to 21 book . The Intersection of Debugging and Testing Debugging and testing play distinct roles in software development. Debugging is the targeted process of identifying and fixing known bugs. Testing, on the other hand, encompasses an adjacent scope, identifying unknown issues by validating expected software behavior across a variety of scenarios. Both are a part of the debug fix cycle, which is a core concept in debugging. Before we cover the cycle, we should first make sure we're aligned with the basic terminology. Unit Tests Unit tests are tightly linked to debugging efforts, focusing on isolated parts of the application—typically individual functions or methods. Their purpose is to validate that each unit operates correctly in isolation, making them a swift and efficient tool in the debugging arsenal. These tests are characterized by their speed and consistency, enabling developers to run them frequently, sometimes even automatically, as code is written within the IDE. Since software is so tightly bound, it is nearly impossible to compose unit tests without extensive mocking. Mocking involves substituting a genuine component with a stand-in that returns predefined results, thus a test method can simulate scenarios without relying on the actual object. This is a powerful yet controversial tool. By using mocking, we're, in effect, creating a synthetic environment that might misrepresent the real world. We're reducing the scope of the test, which might perpetuate some bugs. Integration Tests Opposite to unit tests, integration tests examine the interactions between multiple units, providing a more comprehensive picture of the system's health. While they cover broader scenarios, their setup can be more complex due to the interactions involved. However, they are crucial in catching bugs that arise from the interplay between different software components. In general, mocking can be used in integration tests, but it is discouraged. They take longer to run and are sometimes harder to set up. However, many developers (myself included) would argue that they are the only benchmark for quality. Most bugs express themselves in the seams between the modules and integration tests are better at detecting that. Since they are far more important, some developers would argue that unit tests are unnecessary. This isn't true; unit test failures are much easier to read and understand. Since they are faster, we can run them during development and even while typing. In that sense, the balance between the two approaches is the important part. Coverage Coverage is a metric that helps quantify the effectiveness of testing by indicating the proportion of code exercised by tests. It helps identify potential areas of the code that have not been tested, which could harbor undetected bugs. However, striving for 100% coverage can be a case of diminishing returns; the focus should remain on the quality and relevance of the tests rather than the metric itself. In my experience, chasing high coverage numbers often results in bad test practices that persist in problems. It is my opinion that unit tests should be excluded from coverage metrics due to the importance of integration tests to overall quality. To get a sense of quality coverage, we should focus on integration and end-to-end tests. The Debug-Fix Cycle The debug-fix cycle is a structured approach that integrates testing into the debugging process. The stages include identifying the bug, creating a test that reproduces the bug, fixing the bug, verifying the fix with the test, and finally, running the application to ensure the fix works in the live environment. This cycle emphasizes the importance of testing in not only identifying but also in preventing the recurrence of bugs. Notice that this is a simplified version of the cycle with a focus on the testing aspect only. The full cycle includes a discussion of the issue tracking and versioning as part of the whole process. I discuss this more in-depth in other posts in the series and my book. Composing Tests with Debuggers A powerful feature of using debuggers in test composition is their ability to " jump to line " or " set value ." Developers can effectively reset the execution to a point before the test and rerun it with different conditions without recompiling or rerunning the entire suite. This iterative process is invaluable for achieving desired test constraints and improves the quality of unit tests by refining the input parameters and expected outcomes. jump to line jump to line set value set value Increasing test coverage is about more than hitting a percentage; it's about ensuring that tests are meaningful and that they contribute to software quality. A debugger can significantly assist in this by identifying untested paths. When a test coverage tool highlights lines or conditions not reached by current tests, the debugger can be used to force execution down those paths. This helps in crafting additional tests that cover missed scenarios, ensuring that the coverage metric is not just a number but a true reflection of the software's tested state. In this case, you will notice that the next line in the body is a rejectValue call, which will throw an exception. I don’t want an exception thrown as I still want to test all the permutations of the method. I can drag the execution pointer (arrow on the left) and place it back at the start of the method. Test-Driven Development How does all of this fit with disciplines like Test-Driven Development (TDD)? It doesn't fit well. Before we get into that, let's revisit the basics of TDD. Weak TDD typically means just writing tests before writing the code. Strong TDD involves a red-green-refactor cycle: Red: Write a test that fails because the feature it tests isn't implemented yet. Green: Write the minimum amount of code necessary to make the test pass. Refactor: Clean up the code while ensuring that tests continue to pass. Red: Write a test that fails because the feature it tests isn't implemented yet. Red : Write a test that fails because the feature it tests isn't implemented yet. Red Green: Write the minimum amount of code necessary to make the test pass. Green : Write the minimum amount of code necessary to make the test pass. Green Refactor: Clean up the code while ensuring that tests continue to pass. Refactor : Clean up the code while ensuring that tests continue to pass. Refactor This rigorous cycle guarantees that new code is continually tested and refactored, reducing the likelihood of complex bugs. It also means that when bugs do appear, they are often easier to isolate and fix due to the modular and well-tested nature of the codebase. At least, that's the theory. https://www.youtube.com/watch?v=yImkjlm08Cw&embedable=true https://www.youtube.com/watch?v=yImkjlm08Cw&embedable=true TDD can be especially advantageous for scripting and loosely typed languages. In environments lacking the rigid structure of compilers and linters, TDD steps in to provide the necessary checks that would otherwise be performed during compilation in statically typed languages. It becomes a crucial substitute for compiler/linter checks, ensuring that type and logic errors are caught early. In real-world application development, TDD's utility is nuanced. While it encourages thorough testing and upfront design, it can sometimes hinder the natural flow of development, especially in complex systems that evolve through numerous iterations. The requirement for 100% test coverage can lead to an unnecessary focus on fulfilling metrics rather than writing meaningful tests. The biggest problem in TDD is its focus on unit testing. TDD is impractical with integration tests as the process would take too long. But as we determined at the start of this post, integration tests are the true benchmark for quality. In that test, TDD is a methodology that provides great quality for arbitrary tests, but not necessarily great quality for the final product. You might have the best cog in the world, but if it doesn't fit well into the machine, then it isn't great. Final Word Debugging is a tool that not only fixes bugs but also actively aids in crafting tests that bolster software quality. By utilizing debuggers in test composition and increasing coverage, developers can create a suite of tests that not only identifies existing issues but also guards against future ones, thus ensuring the delivery of reliable, high-quality software. Debugging lets us increase coverage and verify edge cases effectively. It's part of a standardized process for issue resolution that's critical for reliability and prevents regressions.

TEST7

hackernoon.com

201-500 employees

Since 2016

COMPANY RANKING

TEST7

EVERGREEN INDEX #10788

Representing this company? Click here to claim and customize this page!

test7 WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

TEST7

hackernoon.com

201-500 employees

Since 2016

COMPANY RANKING

TEST7

EVERGREEN INDEX #10788

RELATED COMPANIESRANK

STORIES ABOUT TEST7

Representing this company? Click here to claim and customize this page!

test7 WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!