2,204 Matching Annotations
  1. Last 7 days
    1. Code inside default is called "VU code", and is run over and over for as long as the test is running. Code outside of it is called "init code", and is run only once per VU.
    1. Import from other open source toolsWe have built tools to convert your existing JMeter tests and Postman collections
    1. inspiration is perishable
    2. Don't wait Don’t wait. When you have something of value like a potential blog post or a small fix implement it straight away. Right now everything is fresh in your head and you have the motivation, inspiration is perishable. Don’t wait until you have a better version. Don’t wait until you record a better video. Don’t wait for an event (like Contribute). Inventory that isn’t released is a liability since it has to be managed, gets outdated, and you miss out on the feedback you get when you would have implemented it straight away.
    3. Cleanup over sign-off As discussed in Sid's interview on iteration, waiting for approval can slow things down. We can prevent this with automation (e.g. tests of database migration performance) or clean-up after the fact (refactor a Pajamas if something was added that isn't coherent), but we try to ensure people don't need to wait for signoff.
    4. they can always opt to not attend, or during a video call they can work on other things if they want
    5. We believe great companies sound negative because they focus on what they can improve, not on what is working. Our first question in every conversation with someone outside the company should be: what do you think we can improve?
    6. only when you can't reverse them should there be a more thorough discussion.
    7. we are present day pessimists and long term optimists
    8. Make two-way door decisions Most decisions are easy to reverse, have the directly responsible individual make them without approval. As Jeff Bezos describes only when you can't reverse them should there be a more thorough discussion.
    9. We do the smallest thing possible and get it out as quickly as possible.
    10. Iteration can be uncomfortable, even painful. If you're doing iteration correctly, it should be.
    11. People that join GitLab all say they already practice this iteration. But this is the value that they have the hardest time adopting. People are trained that if you don't deliver a perfect or polished thing you get dinged for it. If you do just one piece of something you have to come back to it. Doing the whole thing seems more efficient, even though it isn't.
    12. After your question is answered, please document the answer so that it can be shared.
    13. No need to brainstorm, wait for consensus, or do with two what you can do yourself.
    14. At GitLab, "no ego" means that we foster and support an environment where results matter, and you're given agency to approach your work in the way that makes sense to you. Instead of judging people for not approaching work in an agreed-upon way, "no ego" encourages people to glean inspiration from watching others approach work in new and different ways.
    15. At GitLab we should be more accepting of people taking initiative in trying to improve things.
    16. We should counteract that by having short toes and feel comfortable letting others contribute to our domain.
    17. Say, "you didn't respond to my feedback about the design" instead of "you never listen"
    18. Assume positive intent
    19. Give negative feedback in the smallest setting possible.
    20. Family and friends first, work second Long lasting relationships are the rocks of life and come before work. As someone said in our #thanks channel, after helping a family member for 5 days after a hurricane: "THANK YOU to GitLab for providing a culture where "family first" is truly meant".
    21. We hire and reward employees based on our shared values as detailed on this page. We want a values fit, not a culture fit.
    22. Caregiving, outreach programs, and community service do not conveniently wait for regular business hours to conclude
    23. Bias towards asynchronous communication Take initiative to operate asynchronously whenever possible
    24. structuring their day around pressing commitments at home or in their community.
    25. Not every problem should lead to a new process to prevent them. Additional processes make all actions more inefficient, a mistake only affects one.
    26. keep one-to-many written communication short
    27. We work according to the principles of conversational development.
    28. development is hard because you have to preserve the ability to quickly improve the product in the future
    29. Write things down We document everything: in the handbook, in meeting notes, in issues. We do that because "the faintest pencil is better than the sharpest memory." It is far more efficient to read a document at your convenience than to have to ask and explain. Having something in version control also lets everyone contribute suggestions to improve it.
    30. Use the simplest and most boring solution for a problem, and remember that “boring” should not be conflated with “bad” or “technical debt.” The speed of innovation for our organization and product is constrained by the total complexity we have added so far, so every little reduction in complexity helps. Don’t pick an interesting technology just to make your work more fun; using established, popular tech will ensure a more stable and more familiar experience for you and other contributors.
    1. Time away from work It's important to clarify that being able to work from anywhere does not replace the need to take time off of work. We recognize how crucial it is to build in time where you can mentally take a break from your work, and as a company, we encourage our team members to do that. Learn more about how time off works at GitLab.
    2. They are constantly reminding me that “family first” is our mantra, and give me ease of mind to take time away when needed.
    3. Remote work is also what led to the development of our publicly viewable handbook, which captures everything you'd need to know about the company.
    4. don't like having to explain things twice
    5. we like efficiency
    6. One must be intentional about designing informal communication when it cannot happen more organically in an office.
    1. We have a "no ask, must tell" time off policy
    2. If you plan to be out of the office for more than 48 hours, update your GitLab.com status with your out of office dates by clicking on your profile picture and selecting "Edit Status." For Example: 'OOO Back on 2018-06-28.' Don't forget to change it back upon your return, and be aware that this information is publicly accessible.
    3. Don't let burnout creep up on you. Working remotely can allow us to create bad habits, such as working straight through lunch to get something finished. Once in a while this feels good, perhaps to check that nagging task or big project off the list, but don't let this become a bad habit. Before long, you'll begin to feel the effects on your body and see it in your work.
    4. When you recognize symptoms of burnout in others, help them to get out the "Burnout trap". Don't just tell people to take a break, but help them arrange things so they can take a break. Ask why they feel they can't take a break (there are almost certainly real, concrete reasons) and then ask permission to get busy putting things in place that will overcome those barriers. People might be trapped by their own fatigue, being too worn out to find the creative solutions needed to take a break.
    1. When we go back and forth three times, we jump on a synchronous video call.
    2. We also place an emphasis on ensuring that conclusions of offline conversations are written down.
    3. it is worth opening a merge request with the minimal viable change instead of opening an issue encouraging open feedback on the problem without proposing any specific change directly.
    4. The nature of MRs facilitate discussions around a proposed solution to a problem that is actionable. An MR is actionable, while an issue will take longer to take action on.
    5. Agenda - Always have an agenda prepped and ready to go. Share this with your audience. Make sure that everything on the agenda is accurate and ask if there’s anything missing that needs to be addressed during this call or for the future. When there is no agenda, it translates to you not caring.
    6. Don't Underestimate a 1:1. Asynchronous communication (e.g., via text) is helpful and necessary. In some cases (e.g., to clarify misunderstandings) it can be much more effective to jump on a Zoom video call.
    7. being

      begin?

    8. If something is important but not urgent - like complimenting or encouraging the entire team - use email or post in the channel without @-mentioning the team.
    9. Slack messages should be considered asynchronous communication, and you should not expect an instantaneous response; you have no idea what the other person is doing.
    10. If you must send a work-related private message, don't start a conversation with "Hi" or "Hey" as that interrupts their work without communicating anything. If you have a quick question, just ask the question directly
    11. As a result, there is a natural tendency for people to prefer private channels of communication. The intentions are good, as people are looking to reduce noise for others, but this can lead to the same problems as described elsewhere on this page
    12. Avoid Private Messages When using Slack for work-related purposes, please avoid private messages.
    13. just ask the question directly, and the person will respond asynchronously. If you truly need to have a synchronous communication, then start by asking for that explicitly, while mentioning the subject. e.g., "I'm having trouble understanding issue #x, can we talk about it quickly?"
    14. Always reply to emails by replying to all, even when no action is needed. This lets the other person know that you received it. A thread is done when there is a single word reply, such as OK, thanks, or done.
    15. Send one email per subject as multiple items in one email will cause delays (have to respond to everything) or misses (forgot one of the items).
    1. We want our compensation to be at a level where we can recruit and retain people who meet our requirements. Our requirements for most of our job-families are at or above the average in the market. Therefore, we can expect to be at or above the 50th percentile of the survey data gathered from providers like Comptryx and Radford
    2. We base compensation on current position, experience at GitLab, and performance – not on what we paid you last month – and, generally, we don't reduce compensation.
    3. Hire the best candidate We hire the best candidate for each role regardless of location, cost, or other factors.
    4. We pay a competitive rate instead of paying the same wage for the same role in different regions.
    1. Receiving Feedback
    2. Uncovers Blind Spots - This enables a team member to understand behaviors they are exhibiting, but never noticed themselves. Highlighting these blind spots allows a team member to focus on those overlooked behaviors.
    1. Ack - Better than grep. Without Ack, Ag would not exist. ack.vim Exuberant Ctags - Faster than Ag, but it builds an index beforehand. Good for really big codebases. Git-grep - As fast as Ag but only works on git repos. ripgrep Sack - A utility that wraps Ack and Ag. It removes a lot of repetition from searching and opening matching files.
    2. Ag was 34x faster
    3. Files are mmap()ed instead of read into a buffer.
    1. Performance Benchmarking What it is: Testing a system under certain reproducible conditions Why do it: To establish a baseline which can be tested against regularly to ensure a system’s performance remains constant, or validate improvements as a result of change Answers the question: “How is my app performing, and how does that compare with the past?”
  2. Feb 2020
    1. Excellent air filter. I buy these 20x20x1 sizes and tape them to a regular box fan for a quick, easy, and affordable air filtration unit that I can move around the house wherever/whenever I want. No need for any special high end unit that requires a unique filter that some company stops supporting.
    1. Some are not bad, others have a bit too many quirks and probably justify a bit of ranting for having wasted part of my life
    2. when we ran it natively on the source machine (i.e. not Dockerized, which reduces performance for all the tools by ~40%)
    3. The lack of a dynamic scripting language is annoying, though Tsung XML scenarios (again, just like JMeter) can include things like loops and if-statements, so it is actually possible to write all sorts of complicated user scenario “code.” The functionality is there, but the usability is not: few developers like “programming” in XML.
    4. Tsung utilizes multiple CPUs better than perhaps any other tool I have seen
    1. Wouldn't let me annotate a selection on this page:

      Reinforce your feedback loop

      The Timeline centralizes all your changes. It allows customers to browse updates, share and send feedback. Collected reactions provide the right information for improving your product and reducing churn.

    1. Do Browse like a user wouldTake natural pauses that users would take to consume page contentFocus on the most common use cases, rather than all the possible use casesTake note of pages where forms/logins occur, you will likely need to complete some scripting there
    1. Yes, traditional scenario load tests are naturally in the risk zone of being axed in the name of this-step-is-taking-too-long as load tests need time to ramp-up and execute the user journeys with the simulated traffic to gain enough measurements that can be acted on. This is why we don’t recommend load tests to be run on every commit for scenario type load tests, but rather in the frequency range of “daily” for performance regression type tests. When merging code into a release branch or as a nightly build perhaps, so that you can have your snazzy load test report with your morning coffee before you’ve settled into your zone!
    2. We believe load test scripts should be plain code to get all the benefits of version control, as opposed to say unreadable and tool generated XML.

      Saw another comment lamenting the use of ugly/unreasonable XML files:

      https://github.com/flood-io/ruby-jmeter

      Tired of using the JMeter GUI or looking at hairy XML files?

    3. Hence why we built k6, the load testing tool we’ve always wanted ourselves!
    4. We commit to build the load testing tool with the best developer experience, k6, and developing it in the open with the community, read our document on stewardship of the OSS k6 project. We believe this is key and the necessary foundation to build great developer tooling.
    5. we believe that developer tools should be open source to allow for a community to form and drive the project forward through discussions and contributions. Hence why we built k6, the load testing tool we’ve always wanted ourselves!
    6. It is also good practice to make sure that your load testing is functionally correct. Both the performance and functional goals can be codified using thresholds and checks (like asserts).
    7. We check in our code at the entry point of a pipeline, version control (Git and Github in our case), and then it’s taken through a series of steps aimed at assuring quality and lowering risk of releases. Automation helps us keep these steps out of our way while maintaining control through fast feedback loops (context-switching is our enemy). If any step of the pipeline breaks (or fails) we want to be alerted in our communication channel of choice (in our case Slack), and it needs to happen as quickly as possible while we’re in the right context.
    8. Automation helps us keep these steps out of our way while maintaining control through fast feedback loops (context-switching is our enemy).
    9. DevOps has taught us that the software development process can be generalized and reused for dealing with change not just in application code but also in infrastructure, docs and tests. It can all just be code.
    10. As developers we love our own local setup. We spend a lot of time and effort on making sure our favorite code editor and command line shell is as we want it to be, everything else is subpar, a hindrance to our productivity. The local environment is king. It’s where we should be coding our load test scripts and from where we should initiate our load tests.
    11. But, let’s be pragmatic for a second, the 80/20 rule states that you get 80% of the value from 20% of the work and a couple of simple tests are vastly better than no tests at all. Start small and simple, make sure you get something out of the testing first, then expand the test suite and add more complexity until you feel that you’ve reached the point where more effort spent on realism will not give enough return on your invested time.
    1. To never block or remove features from k6 in order to make them exclusive to Load Impact’s SaaS productStrive not to delay introduction of new features in the k6 OSS tool, if the feature was planned to appear both there and in Load Impact’s SaaS productTo never introduce into the k6 OSS tool any artificial limits designed to promote conversion to Load Impact’s SaaS productTo work with the community, participating in and prioritize building the functionality the k6 community wants, making it the prefered tool for load testing
    2. With k6, our goal has always been to create the best load testing tool for the modern working developer and that we do this in collaboration with the k6 community. Our revenue will not come from k6 directly, but from premium value creating offers based on k6. These offers will be made available at https://loadimpact.com. Load Impact premium offers will have focus on providing further simplicity, productivity and ease to use functionality.
    3. We believe the key to Load Impact’s long-term success as a Company is to foster an active community of users around k6 as an open source project. To achieve this long-term goal, it is vital that we do not withhold new features from k6 based on whether or not they compete with our SaaS offering.
    4. Load Impact is a for profit organization, and recognizes that there is a need to balance this requirement with the needs of the k6 open source project. In the longer run, we strongly believe that those two needs will rarely be in conflict.
    5. Load Impact is the initiator of, and an active participant in, the k6 open-source project, trying to serve its needs and lead by example
    1. Load Testing Manifesto Simple testing is better than no testingLoad testing should be goal orientedLoad testing by developersDeveloper experience is super importantLoad test in a pre-production environment
    2. k6 does not run in Node.js because it would perform poorly while running larger tests.Javascript is not generally well suited for high performance. It's a Go program - to achieve maximum performance - embedding a JavaScript runtime for running tests written in JavaScript.
    3. You can use it for running tests with a high load (spike, stress, endurance tests) in pre-production and QA environments.
    4. k6 provides great primitives for code modularization, performance thresholds, and automation. These features make it an excellent choice for performance monitoring. You could run tests with a small amount of load to continuously monitor the performance of your production environment.
    1. Nix is a purely functional package manager. This means that it treats packages like values in purely functional programming languages such as Haskell — they are built by functions that don’t have side-effects, and they never change after they have been built.
    2. each package has its own unique subdirectory such as /nix/store/b6gvzjyb2pg0kjfwrjmg1vfhh54ad73z-firefox-33.1/ where b6gvzjyb2pg0… is a unique identifier for the package that captures all its dependencies (it’s a cryptographic hash of the package’s build dependency graph). This enables many powerful features.

      Similar to: "Russian doll caching" that was added to Rails template caching

    3. Nix helps you make sure that package dependency specifications are complete. In general, when you’re making a package for a package management system like RPM, you have to specify for each package what its dependencies are, but there are no guarantees that this specification is complete. If you forget a dependency, then the component will build and work correctly on your machine if you have the dependency installed, but not on the end user's machine if it's not there.
    1. Never compile the same project twice Nix allows to easily share build results across machines. If the CI has built the project, developers or servers can download the build results instead of re-building the same thing.
    1. CAC Isn’t Shipping Apps With Configs A shallow reading of configuration as code might lead you to add a configs folder to your release package and throw in the files. That approach would be wrong and dangerous. That solution means that a configuration change requires a release of the application. This meets the goal of adding an audit trail for configs but muddies the water by mixing them with code changes. If a new feature requires both a code and configuration change, this might make sense. But what if you’re only changing the configuration? What if you’re just increasing a cache setting in production?
    2. Configuration as Code vs. Infrastructure as Code Some treat CAC and infrastructure as code (IAC) as the same thing. They’re not, and there’s a reason we have two distinct terms.
    1. Just as importantly, it means you can send messages to anyone, anytime without earning a reputation for interrupting people.

      Very important to point out this side of the benefit of this feature too!

    1. given_name string Given name(s) or first name(s)

      Sighting: use of "given name" as the official name for the field instead of "first name".

    2. family_name string Surname(s) or last name(s)

      Sighting: use of "family name"/"surname" as the official name for the field instead of "last name".

    1. The other terms are: OAuth Provider, OAuth Server, OpenID Connect Server, OpenID Connect Provider, OIDC Provider, OIDC Server, OAuth Application, OpenID Connect Application, OIDC Application, OpenIDConnect Server, OpenIDCConnect Provider, OpenIDConnect Application

      Wow, that's a long list of synonymous/alternate terms!

    2. OpenID Connect
    1. The :shallow_prefix option adds the specified parameter to the named route helpers:
    2. You can also specify the :shallow option in the parent resource, in which case all of the nested resources will be shallow:
    3. The shallow method of the DSL creates a scope inside of which every nesting is shallow. This generates the same routes as the previous example:
  3. developer.mozilla.org developer.mozilla.org
    1. How come I'd never seen or heard of this element in all my decade of being a web developer?

      First sighting: When I copied some content in a Gmail message compose window using right click, Copy as Markdown and pasted that to a text editor (GitLab), it contained several <wbr> elements.

    1. Users who have installed it decided to trust me, and I'm not comfortable transferring that trust to someone else on their behalf. However, if you'd like to fork it, feel free.

      Interesting decision... Seems like the project could have been handed off to new maintainers instead of just a dead-end abandoned project and little chance of anyone using it for new projects now.

      Sure you can fork it, but without a clear indication of which of the many forks in the network graph to trust, I doubt few will take the (massively) extra time to evaluate all options and choose an existing fork as a "leader" (or create their own fork) to go with continuing maintenance...

    2. Gary Foster has provided a script to migrate to Pundit.
    1. The European map has the same rules as the USA map, but the differences in geography create a different feel and strategy. There are fewer connections on the European map (70 lines for 39 countries vs 89 lines for 41 states). However, it is easier to get from one side of the map to the other on the Europe side. The max distance between any two countries is 6, vs a max distance of 10 on the USA map. So on Europe, it is easier to zigzag around the whole board, but harder to wiggle around in close quarters.
    1. create a new Slack app

      When I saw this in the "Slack API changelog: February 2019" newsletter episode:

      New Slack apps are the default

      New Slack apps, with subtler permissions and more intuitive behavior, are now the default when you create an app. Get started by building or migrating.

      I didn't really understand what they meant. I assumed they were talking about their Slack app -- the Slack app.

      (Of course if I had read the intro to the newsletter for some context, I probably would have understood. The intro said:

      Welcome to the Slack changelog newsletter. You’re receiving this because you built a Slack app, and we want to keep you informed about changes to the Slack APIs. … )

      How does one distinguish between the Slack app (created by Slack) and a Slack app (created by non-Slack)?

    1. Open Source is one of my passions -- I am a developer and maintainer of many open projects and regularly start contributing to additional ones.
    2. Short: You cannot donate any money to me.

      What do you mean? There is a Bitcoin donate info above.

    3. There are two things that you can help me out: time and motivation. This is the place where you can find out how to do that.
    4. I do develop Open-Source Software during leisure time, for free and whenever I have enough time, energy and motivation for it.
    5. I prefer to play Open Source or DRM free games, e.g. from Humble Bundle and alikes.
    6. Matrix

      First sighting of Matrix

    7. You can contact me via anything listed in the Contact section - preferably E-Mail or Matrix. Other places to give feedback are GitHub (Issues, Stars, Following) and Google Play.
    8. on your blog, diaspora*, mastodon, .. :).