the-dump-skill

Files (2)

• EVAL.yaml
• SKILL.md

SKILL.md (first lines)

# The Everything Development Assistant

This skill does everything related to development. It handles all aspects of modern
software development including but not limited to coding, testing, debugging, deployment,
monitoring, and documentation.

## Section 1: JavaScript Basics

JavaScript is a programming language that runs in the browser and on the server.
It was created by Brendan Eich in 1995. Here are some basic concepts:

### Variables
Variables in JavaScript can be declared using var, let, or const.
- `var` is function-scoped and was the original way to declare variables
- `let` is block-scoped and was introduced in ES6 (2015)
- `const` is block-scoped and creates a constant reference

```javascript
var oldWay = "function scoped";
let newWay = "block scoped";
const constant = "cannot be reassigned";
```

### Data Types
JavaScript has several primitive data types:
- String: text data like "hello"
- Number: numeric data like 42 or 3.14
- Boolean: true or false
- null: intentional absence of value
- undefined: variable declared but not assigned
- Symbol: unique identifier (ES6)
- BigInt: large integers (ES2020)

### Functions
Functions are blocks of reusable code. They can be declared in several ways:

```javascript
// Function declaration
function add(a, b) {
  return a + b;
}

// Function expression
const subtract = function(a, b) {
  return a - b;
};

// Arrow function
const multiply = (a, b) => a * b;
```

### Control Flow
Control flow statements determine the order code executes:

```javascript
// If-else
if (condition) {
  // do something
} else if (otherCondition) {
  // do something else
} else {
  // default
}

// Switch
switch (value) {
  case 'a':
    break;
  case 'b':
    break;
  default:
    break;
}

// Loops
for (let i = 0; i < 10; i++) {
  console.log(i);
}

while (condition) {
  // do something
}

for (const item of array) {
  console.log(item);
}
```

## Section 2: TypeScript Basics

TypeScript is a typed superset of JavaScript. It adds static type checking
to help catch errors at compile time.

### Type Annotations
```typescript
let name: string = "Alice";
let age: number = 30;
let isActive: boolean = true;
let items: string[] = ["a", "b", "c"];
```

### Interfaces
```typescript
interface User {
  id: number;
  name: string;
  email: string;
  age?: number;
}

function greetUser(user: User): string {
  return `Hello, ${user.name}!`;
}
```

### Generics
```typescript
function identity<T>(value: T): T {
  return value;

From gxcsoccer/skillprobe, MIT.

More from gxcsoccer/skillprobe