# data[].attributes.attachment_link.authors[].name
Алексей Лапин

# data[].attributes.body
A)resilience

B)scale up

C)dependent

D)Batches

E) process across

F) handles

G) Tweaking

H) timeframe

I) Processes across

J) Logged into

K) Synchronously

# data[].attributes.body
A: resilience

B: scale up

C: dependent

D: Batches

E: process across

F: synchronously

G: tweaking

H: timeframe

I: replay

J: logged into

K: handles

# data[].attributes.body
A. resilience

B. scale up
C. synchronously

D. batches.
E. handles

F. dependent

G. tweaking.

H. timeframe.
I. replay

J. logged into

K. processes across

# data[].attributes.body
A - resilience

B - scale up

C - dependent

D - batches

E - process across

F - synchronously

G - tweaking

H - timeframe

I - replay

J - logged into

K - handles

# data[].attributes.body
A resilience

B scale up

C dependent

D batches

E processes across

F handles

G tweaking

H timeframe

I replay

J logged into

K synchronously

# data[].attributes.body
A - resilience

B - scale up

C - dependent

D - Batches

E - processes across

F - handles

G - tweaking

H - timeframe

I - replay

J - logged into

K - synchronously

# data[].attributes.body
Firstly we need to mention our advantages, after that docs and stack

# data[].attributes.headline
Group Middle (really big and rich people)

# data[].attributes.subject
Group Middle (really big and rich people)

# data[].attributes.body
Revenue plan

Target audience

Why we better

Market observation

Plan B (grab money and run 🏃‍♂️ )

How much money we need, AND WHY??

Say thank you for yours money.

# data[].attributes.body
1) examples

2) explanation of the terms

3) screenshots

4) simple language

5) step-by-step instruction

# data[].attributes.body
https://docs.google.com/presentation/d/1gsKgJ3sCc4VEyljXs7kN7rVmxT-F_0-7lp12qmtxvo4/edit

# data[].attributes.body
https://docs.google.com/presentation/d/1Pn9lWkW2DOzp64x_OSAeN7O5vsDjqoBbiILLs6nl1-Q/

# data[].attributes.body
Incompleteness

Outdated Information

Absence of examples

# data[].attributes.body
Lack of examples
Outdated information
Overuse of jargon

# data[].attributes.body
Hard English

documentation without examples

incomplete documentation

# data[].attributes.body
too much fluff
bad font size
not related inforamtion to the topic

# data[].attributes.attachment_link.readable_text
Good technical documentation is essential for effective communication and understanding of your product. It helps users understand how to use and troubleshoot the technology, and it can also serve as a valuable resource for developers to understand the design and implementation of the system. Clear and comprehensive technical documentation can greatly improve a developer's experience with your product.

On the other hand, poor technical documentation can lead to confusion and frustration for developers, as well as wasted time and resources. Examples of poor documentation include non-existent or difficult-to-find pages, broken documentation with incorrect or broken links, and inaccurate docs that don't reflect the current state of the product. Poor documentation makes it difficult for developers to understand the product and slows down the development process.

In this post, we will examine the various types of poor documentation and provide examples, solutions, and best practices for creating comprehensive and effective technical documentation for developers.

1. Can't Find It or It's Not There

Perhaps the worst documentation is the one that doesn't even exist. Developers look for your docs to see what's possible. There's no way to tell what you can build if documentation isn't made available. That said, this bad docs mistake still comes in a couple of flavors.

The first is purposely hidden documentation. Despite the well-known dev desire for self-sufficiency, many organizations still purposely withhold documentation. The business reasoning here is that you can better understand what someone is looking to solve. Unfortunately, the vast majority of developers will never reach out to request your documentation.

Other companies hide documentation behind a login, often for similar reasoning. A free account usually requires an email address, which means you'll have a way to contact the potential customer in the future.

Again, many devs will want to see the docs to decide whether it's worth creating an account.

The last two non-existent docs issues appear exactly the same to devs:

1. Documentation is not prominently linked

2. Documentation has not been written yet

If your audience can't find it, it might as well not have been written. The solutions to these problems, of course, are very different. Your team will either need to create the docs or make them discoverable on your website.

In our recent review of top dev company homepages, only about half mention developers or documentation in global navigation. Of the remaining companies, almost all of them provide a documentation link one more click away, usually under a "resources" menu.

2. Broken, Inaccurate, and Outdated

Some may argue that wrong documentation is worse than no documentation. Indeed, this is consistently listed as a top frustration of developers. Of course, there are a number of ways that documentation can be wrong.

It might be an edge case that's not covered, like returning a null field when something is expected. Or the classic API mistake of an error message mixed with a 200 status code that suggests all is OK.

Problems of incomplete documentation are hard to find and infuriating when developers bump into them.

You can have other issues that are easier to discover and still annoying for someone browsing your docs. We frequently find links within documentation that go nowhere-404 in web parlance. Now imagine it's the exact page you need to complete your project.

Once, I received a report from a developer that our product had "read more" links as plain text, without actually linking. I scoured the docs, but couldn't find it. Eventually, deep within the dashboard, was helper text that had somehow been stripped of its links. Even worse, there were several of them and we couldn't figure out how long it had been that way.

Whether it's wrong because something has changed or it was never right in the first place, what's important is what happens next. Yes, there are processes you can put in place to catch some of this automatically, but make sure there's a clear line of communication with devs. Make it clear where to get support, provide a feedback tool for every docs page, and-here comes the hard part-read and react to the bug reports.

3. Click Here to Download the Docs

When I asked around for bad documentation examples, there was one immediate response. In fact, you can use this acronym with most developers and see a visceral reaction to this particular document format. For years, I counted on it as a punchline in talk, just by showing this image.

Yes, PDFs are the classic bad docs experience embedded in developer brains. The document itself makes it difficult to browse, copy-paste, and share deep links with other developers. But the aversion may go to the types of products that are documented in this way. Usually, it's a sign of other problems.

For example, take a look at the US Postal Service docs (USPS). Granted, there's a non-PDF version, which they somehow make feel like a PDF (and that "HTM" extension alone inspires a grimace).

In fact, while at Lob, Sid Maestre published a modern version of the USPS docs. Many devs may still find problems with the API (such as XML responses), but uspsweb.tools is a huge improvement over the legacy experience.

Of course, PDFs are just one file format of several you might see: Word docs, Excel, Powerpoint, and many others have been reported. Even an OpenAPI document, a format we love for its contributions to DX, is not sufficient documentation.

Lastly, the other problem with downloads is they're often paired with a sales form. If devs hate PDFs, I'm not sure there's a strong enough word to describe how they feel about sales forms.

4. The One-Trick Pony

You can do none of the previous documentation mistakes and still not provide documentation that helps devs. Most commonly, we see this with reference-only documentation. It tells you all the facts you need to use a product, but nothing to help you connect the dots in the right order. Despite what devs may even say themselves, "just show me the docs" doesn't work.

The classic sign that there's only one type of documentation is when your docs are nearly indistinguishable from the default Swagger Petstore.

In addition to a reference, which only covers the functional details, you want to include other types of documentation:

Contextual "why this matters" documentation

Tutorials to take you step-by-step through a project

Sample apps and code snippets to solve common problems

You might even consider switching up the format. Experiment with video and other ways of communicating about your product, such as these innovative tutorial formats.

5. No Opinion, No Narrative

Somewhat related to the one-trick pony, this final bad documentation example is worthy of its own section. Including multiple types of content does not necessarily mean the story will resonate with the audience. Even documentation should include some voice of the company.

Your docs need to explain more than how someone builds with your product. They must explain why developers would want to integrate it.

Many Google APIs use a structure that helps them avoid being a one-trick pony without any narrative. Guides, in particular, are where the company shares its important use cases-and, yes, how to implement them.

It's in these guides that you might also be able to inject some of your company or product opinion. That may run counter to how you think of documentation. The most opinionated content will likely be published on your blog, but consider that your product exists because it solves a need in an opinionated way. Don't hide it-share it and you'll help developers have better, faster success with your product.

Learn From Great Documentation

It's one thing to avoid these documentation mistakes, but it may be better to look at the ones that get it right.

We've collected nine of the best API documentation examples, including Plaid, Twilio, and Stripe. Rather than copy everything one company does, why not take the best from each? The post covers the full spectrum of documentation types and best practices.

If you need guidance from the EveryDeveloper team, the best way is to reach out for our objective opinion. We can perform a DX Review, which includes your documentation and other areas that impact the developer experience.

# data[].attributes.attachment_link.title
Examples of Bad Documentation (And How to Do Better)

# data[].attributes.attachment_link.description
Good technical documentation is essential for effective communication and understanding of your product. It helps users understand how to use and troubleshoot the technology, and it can also serve as a valuable resource for developers to understand the design and implementation of the system. Clear

# data[].attributes.attachment_link.title
Progress test on algorithms/data structures/UI

# data[].attributes.body
F Software features are described as user scenarios required for a certain task
E Contains architecture description
G Troubleshooting information
A Navigation
B FAQs section
I Screenshots (vs text only)
H Video tutorials
J Information on system's compatibility and behaviour in different environments
C Responsive design when viewing on mobile device
D Simple English

# data[].attributes.body
A. Navigation-10

B. FAQs section-8

C. Responsive design when viewing on mobile device-6

D. Simple English-9

E. Contains architecture description-3

F. Software features are described as user scenarios required for a certain task-5

G. Troubleshooting information-4

H. Video tutorials-7

I. Screenshots (vs text only)-2

J. Information on system's compatibility and behaviour in different environments -1

# data[].attributes.body
1. Software features are described as user scenarios required for a certain task
2.  Troubleshooting information
3. Information on system's compatibility and behaviour in different environments
4. Contains architecture description
5. Video tutorials
6. Screenshots (vs text only)

7. FAQs section
8. Simple English
9. Navigation
10. Responsive design when viewing on mobile device

# data[].attributes.body
A. Navigation

F. Software features are described as user scenarios required for a certain task

E. Contains architecture description

D. Simple English

J. Information on system's compatibility and behaviour in different environments

C. Responsive design when viewing on mobile device

B. FAQs section

G. Troubleshooting information

H. Video tutorials

I. Screenshots (vs text only)

# data[].attributes.body
1) D - Simple English
2) A - Navigation
3) F - Software features are described as user scenarios required for a certain task
4) J - Information on system's compatibility and behaviour in different environments
5) I - Screenshots (vs text only)
6) E - Contains architecture description
7) H - Video tutorials
8) B - FAQs section
9) G - Troubleshooting information
10) C - Responsive design when viewing on mobile device

# data[].attributes.body
F. Software features are described as user scenarios required for a certain task
A. Navigation
J. Information on system's compatibility and behaviour in different environments
B. FAQs section
I. Screenshots (vs text only)
H. Video tutorials
E. Contains architecture description
G. Troubleshooting information

C. Responsive design when viewing on mobile device
D. Simple English

# data[].attributes.body
I always directly speak

# data[].attributes.body
I directly think about UI and UX

# data[].attributes.body
You can find effortlessly our website.

# data[].attributes.body
You need to simply go and try it

# data[].attributes.body
I should definitely do the lab work tommorow

# data[].attributes.body
I simply wrote it.

# data[].attributes.body
i definetly understood the topic

# data[].attributes.body
I can easily do this

# data[].attributes.body
dropdowns

checkbox

modal window

customizing options

layout

scroll bar

input field

toolbars

panels

welcome screen

file management

page view options

html

recent files

3.

main menu

interface

functional

# data[].attributes.body
7.dropdowns
4.customizing options
6.file management
2.welcome screen
1. default layout
3.window/page view options
8.toolbars
5.panels

1. familiar
2. insert panel
3. panel brue?
4. grue

# data[].attributes.body
default layout

welcome screen

window/page view options

panels

file management

customizing options

dropdowns

toolbars

insert panel
tab
menu
link
screen
button
styles

# data[].attributes.body
default layout
welcome screen
window/page view options
panels
file management
customizing options
dropdowns
toolbars

1. Useful UI Vocab
depends on, change, part of, insert, layout

2. UI elements
menu, toolbars, page, dropdowns, screen, split screen, icon, recent files, fonts, features, properties, options

3. Plan/Logic of UI Presentation
1) You need to describe the main menu
2) You need to describe each element of interfaces
3) You need to explain what elemets can do

# data[].attributes.body
1)
layouts
button
insert form
toolbars
panel
menu
tags ans style

2)
table
img
lists
panels
tabs
menu

3)
how start project
explaining interface and functions of software
file system; open or create
toolbars navigation
main functions of tools

order:
1)welcome screen
2)file managment
3)page view options
4)panel
5)dropdowns
6)customizing options
7) toolbars

# data[].attributes.body
Words
- Designer
- Recent files
- Link
- Brand new
- Html tags
- List of layouts
- Css styles
- Property Inspector
- Menu bar
- Document toolbar
- Insert panel
- Insert different types of elements
- Tab

Order:
- dropdowns
- customizing options
- welcome screen
- file management
- window/page view options
- default layout
- toolbars
- panels

# data[].attributes.body
4 dropdowns
6 customizing options
3 file management
2 welcome screen
1 default layout
7 window/page view options
5 toolbars
5 panels

change title
click OK
more convinient for u
make a fullscreen

# data[].attributes.body
- panel
- menu bar
- checkbox
- scroll box
- click and drag
- layout
- toolbars

# data[].attributes.attachment_link.title
A Quick Overview of the  Dreamweaver Interface.mp4

# data[].attributes.body
Console is a physical working terminal (e.g. keyboard, display). Panel is roughly equated to window.

# data[].attributes.body
https://app.nearpod.com/?pin=kay2s

kay2s

# data[].attributes.attachment_link.description
Engage and assess your students in every lesson!

# data[].attributes.body
Root
Bubble it up
Min heap
Max heap
Node
Leaf

# data[].attributes.body
root

compare

bubble it up

swap

insert element

spot

node

# data[].attributes.body
root
tree
empty spot
gaps
swap

# data[].attributes.body
- node
- heap
- spot
- root node
- tree

# data[].attributes.body
Heap
min or max
tree
index
basics
insertion
empty spot
top
bubble up
out of order
swap
removing
middle
implementation
gaps
array
compact
map

# data[].attributes.body
single pointer

node

pointer

flexible

balanced

Partitioned

Disjoint

Permutation

Adjacent

# data[].attributes.body
Hashmap
Index mapped to the value
Key
characters, strings
flexible
order
relevant
constant time
insert, remove, search

Queue
Push front/back
Pop front/back
cases
linked list
a set pf elements
order
add
deque = double queue
back
constant time

# data[].attributes.body
Binary Tree
- key value
- mapped
- node
- balanced
- dfs
Graph
- directed graph
- adjacency list
- edges
- vertices

# data[].attributes.body
array - Index, sorted out - Insert, get, delete, SIze

stack - Undo, last-in-first-out (LIFO) - Push, pop, IsEmpty, top

queue - First-in-first-out (FIFO), reverse - Enqueue, dequeue, IsEmpty, top

LinkedList - Node, pointer, adjacency, loop, duplicates - InsertAtEnd, InsertAtHead, DeleteAtHead, Search, isEmpty

Graph - Vertex (pl. vertices), edge, weight/cost, traverse, cycle - Breadth First Search

tree - Root, parent, child, sibling, leaf, ancestors - Binary, balanced

HashTable - Key, dictionary, collision, hash

# data[].attributes.body
1. Array | index, sorted out | Insert, get, delete, size
2. Stack | Undo, last-in-first-out (LIFO) | Push, pop, IsEmpty, top
3. Queue | First-in-first-out(FIFO), reverse | Enqueue, dequeue, IsEmpty, top
4. Linked-list | Node, pointer, adjacency, loop, duplicates| InsertAtEnd, InsertAtHead, DeleteAtHead, Search, isEmpty
5. Graph | Vertex (pl. vertices), edge, weight/cost, traverse, cycle | Breadth First Search
6. Tree | Root, parent, child, sibling, leaf, ancestors | Binary, balanced
7. Dictionary | Key, dictionary, collision, hash | Resizing, chaining

# data[].attributes.body
1 - array - Index, sorted out - Insert, get, delete, size
2 - stack - Undo, last-in-first-out (LIFO)  - Push, pop, IsEmpty, top
3 - queue -  First-in-first-out(FIFO), reverse - Enqueue, dequeue, IsEmpty, top
4 - LinkedList - Node, pointer, adjacency, loop, duplicates - InsertAtEnd, InsertAtHead, DeleteAtHead, Search, isEmpty
5 -  Graph - Vertex (pl. vertices), edge, weight/cost, traverse, cycle -  Breadth First Search
6 - tree - Root, parent, child, sibling, leaf, ancestors  - Binary, balanced
7 - HashTable - Key, dictionary, collision, hash - Resizing, chaining

# data[].attributes.body
- swap
- merged
- sorted array
- sequence
- perform a merge
- again
- repeat

# data[].attributes.body
merge sort vs quick sort
let's assume
fully sorted list
compare elements and repeat it again
sorted order
moving elements
pivot randomly chosen
final merge
swap array

# data[].attributes.body
compare balls, quick sort, fully sorted, merge sort longer than quick sort, sorted order

# data[].attributes.body
swap, algorithm, merge

# data[].attributes.body
repeat again and again
repeat until something
swap
merged
algorithm
Performans

comparisons

# data[].attributes.body
sorted order, to perform a merge algorithm, sequence

# data[].attributes.attachment_link.provider_name
Wordwall - Create better lessons quicker

# data[].attributes.attachment_link.description
Match up - Drag and drop each keyword next to its definition.

# data[].attributes.body
1. array
2. pick
3. pivot
4. assume
5.  randomly
6. walk through
7. swap around
8. division
9.repeat
10. apply to
11. eventually
12. sorted
13. to
14. greater
15. pointer
16. arrangement
17. do
18. move over
19 progressively
20. wind up with
21. median
22. get pivoted
23. runtime
24. subarray

# data[].attributes.body
1. array

2. pick

3. pivot

4. assume

5. randomly

6. walk through

7. swap around

8. division

9. repeat

10. apply to

11. eventually

12. sorted

13. to

14. greater

15. pointer

16. arrangement

17. do

18. move over

19. progressively

20. wind up with

21. median

22. get pivoted

23. runtime

24. subarray

# data[].attributes.body
1. array
2. Pick
3. pivot
4.assume
5. randomly
6. walk through
7. swap around
8. division
9. repeat
10. apply to
11. eventually
12. sorted
13. to
14. greater
15. pointer
16. Arrangement
17. do
18. move over
19. progressively
20. wind up with
21. median
22. get pivoted
23. runtime
24. subarray

# data[].attributes.body
1 array

2  pick

3 pivot

4 assume

5 randomly

6 walk through

7 swap around

8 devision

9 repeat

10 apply to

11 eventually

12 sorted

13 to

14 grater

15 pointer

16 arrangement

17 do

18 move over

19 progressively

20 wind up with

21 median

22 get pivoted

23 runtime

24 subarray

# data[].attributes.body
1. Array
2. Pick
3. Pivot
4. Assume
5. Randomly
6. Walk through
7. Swap around
8. Division
9. Repeat
10. Apply to
11. Eventually
12. Sorted
13. To
14. Greater
15. Pointer
16. Arrangement
17. Do
18. Move over
19. Progressively
20. Wind up with
21. Median
22. Get pivoted
23. Runtime
24. Subarray

# data[].attributes.body
1. array
2. pick
3. pivot
4. assume
5. randomly
6. do
7. swap around
8. division
9. repeat
10. apply to
11. Eventually
12. sorted
13. left
14. greater
15. pointer
16. arrangment
17. to
18. move over
19. progressivly
20. wind up with
21. median
22. get pivoted
23. runtime
24. subarray

# data[].attributes.body
1. array
2.pick
3.pivot
4.assume
5.randomly
6.walk through
7.swap around
8.division
9.repeat
10.apply to
11.eventually
12.sorted
13.to
14.greater
15.pointer
16.arrangement
17.do
18.move over
19.progressively
20.wind up with
21.median
22.get pivoted
23.runtime
24.subarray

# data[].attributes.body
x cubed
cubic root of t
f of x
x maps to f(x)
x inverse

# data[].attributes.body
• a minus b
• the ray from a to b
• f from U to V
• A intersected with B
• x cubed

# data[].attributes.body
Complement
strictly
Inverse
maps

# data[].attributes.body
1. union
2. empty set
3. two thirds
4. cubic root of f
5. times

# data[].attributes.body
x inverse
the complement of A
x maps to f(x)
the ray from a to b
sine

# data[].attributes.body
- the ray from a to b
- x maps to f(x)
- union
- the empty set
- x belongs to A

# data[].attributes.body
x maps to f(x)
the compliment of A
f of x
the ray from a to b
the empty set

# data[].attributes.body
the complement of A
x maps to f(x)
the directed line segment from a to b
the ray from a to b
x belongs to A

# data[].attributes.body
Union

Complement

Inverse

The ray from a to b

Maps

# data[].attributes.body
f of x
x maps to f(x)
empty set
x inverse
cubic root

# data[].attributes.body
plus
times
f from U to V
f of x
empty set

# data[].attributes.body
x inverse
f of x
x maps to f(x)
cosinus
tangent

# data[].attributes.body
https://t.me/+eGROFiv4A1YzNDI6

# data[].attributes.body
Excuse me. Do you mind if I join you?
Are you here alone or with a the group?
Could you pass me the milk?