1{
2  "ULID Generator": "ULID జనరేటర్",
3  "Introduction": "పరిచయం",
4  "A ULID (Universally Unique Lexicographically Sortable Identifier) is a unique identifier that combines a timestamp with random data to create a 26-character string. ULIDs are designed to be lexicographically sortable while maintaining a high degree of uniqueness and randomness.": "ULID (యూనివర్సల్ యూనిక్ లెక్సికోగ్రాఫికల్ సార్టబుల్ ఐడెంటిఫయర్) అనేది టైమ్‌స్టాంప్‌ను యాదృచ్ఛిక డేటాతో కలిపి 26-అక్షరాల స్ట్రింగ్‌ను సృష్టించడానికి ఉపయోగించే ప్రత్యేక గుర్తింపు. ULIDs లెక్సికోగ్రాఫికల్‌గా సార్టబుల్‌గా ఉండటానికి రూపొందించబడ్డాయి, ఇదే సమయంలో ప్రత్యేకత మరియు యాదృచ్ఛికతను అధికంగా ఉంచుతాయి.",
5  "Structure of a ULID": "ULID యొక్క నిర్మాణం",
6  "A ULID consists of two main parts:": "ULID రెండు ప్రధాన భాగాలను కలిగి ఉంటుంది:",
7  "Timestamp (10 characters): The first 10 characters represent the time in milliseconds since the Unix Epoch (1970-01-01).": "టైమ్‌స్టాంప్ (10 అక్షరాలు): మొదటి 10 అక్షరాలు యునిక్స్ ఎపోచ్ (1970-01-01) నుండి మిల్లీసెకండ్లలో సమయాన్ని సూచిస్తాయి.",
8  "Randomness (16 characters): The remaining 16 characters are generated using cryptographically secure random data.": "యాదృచ్ఛికత (16 అక్షరాలు): మిగిలిన 16 అక్షరాలు క్రిప్టోగ్రాఫిక్‌గా సురక్షితమైన యాదృచ్ఛిక డేటాను ఉపయోగించి రూపొందించబడతాయి.",
9  "The resulting 26-character string is encoded using Crockford's base32 alphabet (0-9 and A-Z, excluding I, L, O, and U).": "ఫలితంగా వచ్చే 26-అక్షరాల స్ట్రింగ్‌ను క్రాక్‌ఫోర్డ్ యొక్క బేస్32 అక్షరమాల (0-9 మరియు A-Z, I, L, O, మరియు Uని మినహాయించి) ఉపయోగించి కోడ్ చేయబడింది.",
10  "Formula": "సూత్రం",
11  "The ULID is generated using the following steps:": "ULIDను క్రింది దశలను ఉపయోగించి రూపొందిస్తారు:",
12  "1. Generate a 48-bit timestamp (milliseconds since Unix Epoch).": "1. 48-బిట్ టైమ్‌స్టాంప్‌ను రూపొందించండి (యునిక్స్ ఎపోచ్ నుండి మిల్లీసెకండ్లు).",
13  "2. Generate 80 bits of cryptographically secure random data.": "2. క్రిప్టోగ్రాఫిక్‌గా సురక్షితమైన యాదృచ్ఛిక డేటా 80 బిట్లను రూపొందించండి.",
14  "3. Encode the combined 128 bits using Crockford's base32 encoding.": "3. క్రాక్‌ఫోర్డ్ యొక్క బేస్32 కోడింగ్‌ను ఉపయోగించి కలిపిన 128 బిట్లను కోడ్ చేయండి.",
15  "Calculation": "హిసాబు",
16  "The ULID generator performs the following steps:": "ULID జనరేటర్ క్రింది దశలను నిర్వహిస్తుంది:",
17  "1. Get the current timestamp in milliseconds.": "1. మిల్లీసెకండ్లలో ప్రస్తుత టైమ్‌స్టాంప్‌ను పొందండి.",
18  "2. Generate 10 random bytes (80 bits) using a cryptographically secure random number generator.": "2. క్రిప్టోగ్రాఫిక్‌గా సురక్షితమైన యాదృచ్ఛిక సంఖ్యా జనరేటర్‌ను ఉపయోగించి 10 యాదృచ్ఛిక బైట్స్ (80 బిట్లు) రూపొందించండి.",
19  "3. Combine the timestamp and random data into a 128-bit integer.": "3. టైమ్‌స్టాంప్ మరియు యాదృచ్ఛిక డేటాను 128-బిట్ పూర్తి సంఖ్యలో కలపండి.",
20  "4. Encode the 128-bit integer using Crockford's base32 encoding.": "4. క్రాక్‌ఫోర్డ్ యొక్క బేస్32 కోడింగ్‌ను ఉపయోగించి 128-బిట్ పూర్తి సంఖ్యను కోడ్ చేయండి.",
21  "Use Cases": "ఉపయోగాల సందర్భాలు",
22  "ULIDs are useful in various scenarios, including:": "ULIDs వివిధ సందర్భాలలో ఉపయోగకరంగా ఉంటాయి, వీటిలో:",
23  "1. Database keys: ULIDs can be used as unique identifiers for database records, ensuring uniqueness and sortability.": "1. డేటాబేస్ కీలు: ULIDs డేటాబేస్ రికార్డుల కోసం ప్రత్యేక గుర్తింపులుగా ఉపయోగించవచ్చు, ప్రత్యేకత మరియు సార్టబిలిటీని నిర్ధారించవచ్చు.",
24  "2. Distributed systems: In distributed environments, ULIDs can be generated without coordination between nodes.": "2. పంపిణీ చేసిన వ్యవస్థలు: పంపిణీ చేసిన వాతావరణాలలో, నోడ్‌ల మధ్య సమన్వయం లేకుండా ULIDs రూపొందించవచ్చు.",
25  "3. Logging and tracing: ULIDs can be used to tag log entries or trace events, providing a sortable and unique identifier.": "3. లాగింగ్ మరియు ట్రేసింగ్: ULIDs లాగ్ ఎంట్రీలను ట్యాగ్ చేయడానికి లేదా ఈవెంట్లను ట్రేస్ చేయడానికి ఉపయోగించవచ్చు, ఇది సార్టబుల్ మరియు ప్రత్యేక గుర్తింపును అందిస్తుంది.",
26  "4. URL-friendly IDs: ULIDs are URL-safe and can be used in web applications as identifiers in URLs.": "4. URL-స్నేహపూర్వక IDs: ULIDs URL-సురక్షితంగా ఉంటాయి మరియు వెబ్ అప్లికేషన్లలో URLsలో గుర్తింపులుగా ఉపయోగించవచ్చు.",
27  "Alternatives": "వికల్పాలు",
28  "While ULIDs are versatile, there are other unique identifier systems to consider:": "ULIDs అనువైనవి అయినప్పటికీ, పరిగణించాల్సిన ఇతర ప్రత్యేక గుర్తింపు వ్యవస్థలు ఉన్నాయి:",
29  "1. UUID (Universally Unique Identifier): A 128-bit identifier that doesn't include a timestamp component.": "1. UUID (యూనివర్సల్ యూనిక్ ఐడెంటిఫయర్): టైమ్‌స్టాంప్ భాగాన్ని కలిగి లేని 128-బిట్ గుర్తింపు.",
30  "2. KSUID (K-Sortable Unique IDentifier): Similar to ULID but with a different timestamp encoding.": "2. KSUID (K-సార్టబుల్ యూనిక్ ఐడెంటిఫయర్): ULID కు సమానమైనది కానీ విభిన్న టైమ్‌స్టాంప్ కోడింగ్‌తో.",
31  "3. Snowflake ID: Twitter's distributed unique ID generation system, which includes a timestamp and worker ID.": "3. స్నోఫ్లేక్ ID: టైమ్‌స్టాంప్ మరియు వర్కర్ IDని కలిగి ఉన్న ట్విట్టర్ యొక్క పంపిణీ చేసిన ప్రత్యేక ID ఉత్పత్తి వ్యవస్థ.",
32  "History": "చరిత్ర",
33  "ULIDs were introduced in 2016 by Alizain Feerasta as an alternative to UUIDs. They were designed to address some limitations of UUIDs, particularly in terms of sortability and readability. The ULID specification has remained stable since its introduction, with various implementations available in different programming languages.": "ULIDs 2016 లో అలిజైన్ ఫీరాస్టా ద్వారా UUIDలకు ప్రత్యామ్నాయంగా పరిచయమయ్యాయి. అవి UUIDల కొన్ని పరిమితులను, ముఖ్యంగా సార్టబిలిటీ మరియు చదవగలిగే విధానాలను పరిష్కరించడానికి రూపొందించబడ్డాయి. ULID స్పెసిఫికేషన్ ప్రారంభించిన తర్వాత స్థిరంగా ఉంది, వివిధ ప్రోగ్రామింగ్ భాషలలో వివిధ అమలు లభ్యమవుతున్నాయి.",
34  "Examples": "ఉదాహరణలు",
35  "Here are some code examples to generate ULIDs in different programming languages:": "ఇక్కడ వివిధ ప్రోగ్రామింగ్ భాషలలో ULIDs రూపొందించడానికి కొన్ని కోడ్ ఉదాహరణలు ఉన్నాయి:",
36  "// JavaScript implementation": "// జావాస్క్రిప్ట్ అమలు",
37  "function generateULID() {": "function generateULID() {",
38  "const timestamp = Date.now().toString(36).padStart(10, '0');": "const timestamp = Date.now().toString(36).padStart(10, '0');",
39  "const randomness = crypto.getRandomValues(new Uint8Array(16))": "const randomness = crypto.getRandomValues(new Uint8Array(16))",
40  ".reduce((acc, byte) => acc + byte.toString(36).padStart(2, '0'), '');": ".reduce((acc, byte) => acc + byte.toString(36).padStart(2, '0'), '');",
41  "return (timestamp + randomness).toUpperCase();": "return (timestamp + randomness).toUpperCase();",
42  "}": "}",
43  "console.log(generateULID());": "console.log(generateULID());",
44  "# Python implementation": "# పితాన్ అమలు",
45  "import time": "import time",
46  "import secrets": "import secrets",
47  "import base64": "import base64",
48  "def generate_ulid():": "def generate_ulid():",
49  "timestamp = int(time.time() * 1000).to_bytes(6, byteorder=\"big\")": "timestamp = int(time.time() * 1000).to_bytes(6, byteorder=\"big\")",
50  "randomness = secrets.token_bytes(10)": "randomness = secrets.token_bytes(10)",
51  "return base64.b32encode(timestamp + randomness).decode(\"ascii\").lower()": "return base64.b32encode(timestamp + randomness).decode(\"ascii\").lower()",
52  "print(generate_ulid())": "print(generate_ulid())",
53  "// Java implementation": "// జావా అమలు",
54  "import java.security.SecureRandom;": "import java.security.SecureRandom;",
55  "import java.time.Instant;": "import java.time.Instant;",
56  "public class ULIDGenerator {": "public class ULIDGenerator {",
57  "private static final SecureRandom random = new SecureRandom();": "private static final SecureRandom random = new SecureRandom();",
58  "private static final char[] ENCODING_CHARS = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\".toCharArray();": "private static final char[] ENCODING_CHARS = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\".toCharArray();",
59  "public static String generateULID() {": "public static String generateULID() {",
60  "long timestamp = Instant.now().toEpochMilli();": "long timestamp = Instant.now().toEpochMilli();",
61  "byte[] randomness = new byte[10];": "byte[] randomness = new byte[10];",
62  "random.nextBytes(randomness);": "random.nextBytes(randomness);",
63  "StringBuilder result = new StringBuilder();": "StringBuilder result = new StringBuilder();",
64  "// Encode timestamp": "// టైమ్‌స్టాంప్‌ను కోడ్ చేయండి",
65  "for (int i = 9; i >= 0; i--) {": "for (int i = 9; i >= 0; i--) {",
66  "result.append(ENCODING_CHARS[(int) (timestamp % 32)]);": "result.append(ENCODING_CHARS[(int) (timestamp % 32)]);",
67  "timestamp /= 32;": "timestamp /= 32;",
68  "}": "}",
69  "// Encode randomness": "// యాదృచ్ఛికతను కోడ్ చేయండి",
70  "for (byte b : randomness) {": "for (byte b : randomness) {",
71  "result.append(ENCODING_CHARS[b & 31]);": "result.append(ENCODING_CHARS[b & 31]);",
72  "}": "}",
73  "return result.toString();": "return result.toString();",
74  "}": "}",
75  "public static void main(String[] args) {": "public static void main(String[] args) {",
76  "System.out.println(generateULID());": "System.out.println(generateULID());",
77  "}": "}",
78  "These examples demonstrate how to generate ULIDs in JavaScript, Python, and Java. You can adapt these functions to your specific needs or integrate them into larger systems requiring unique identifiers.": "ఈ ఉదాహరణలు జావాస్క్రిప్ట్, పితాన్ మరియు జావాలో ULIDs ను ఎలా రూపొందించాలో చూపిస్తాయి. మీరు ఈ ఫంక్షన్‌లను మీ ప్రత్యేక అవసరాలకు అనుకూలీకరించవచ్చు లేదా ప్రత్యేక గుర్తింపులను అవసరమైన పెద్ద వ్యవస్థలలో సమీకరించవచ్చు.",
79  "References": "సూచనలు",
80  "1. \"ULID Specification.\" GitHub, https://github.com/ulid/spec. Accessed 2 Aug. 2024.": "1. \"ULID స్పెసిఫికేషన్.\" GitHub, https://github.com/ulid/spec. 2024 ఆగస్టు 2 న ప్రాప్తించబడింది.",
81  "2. \"Crockford's Base32 Encoding.\" Base32 Encoding, http://www.crockford.com/base32.html. Accessed 2 Aug. 2024.": "2. \"క్రాక్‌ఫోర్డ్ యొక్క బేస్32 కోడింగ్.\" బేస్32 కోడింగ్, http://www.crockford.com/base32.html. 2024 ఆగస్టు 2 న ప్రాప్తించబడింది.",
82  "3. \"UUID vs ULID.\" Stack Overflow, https://stackoverflow.com/questions/54222235/uuid-vs-ulid. Accessed 2 Aug. 2024.": "3. \"UUID vs ULID.\" స్టాక్ ఓవర్‌ఫ్లో, https://stackoverflow.com/questions/54222235/uuid-vs-ulid. 2024 ఆగస్టు 2 న ప్రాప్తించబడింది."
83}
84