1. Список говнокодов пользователя lisp-worst-code

    Всего: 14

  2. Haskell / Говнокод #29198

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    (ql:quickload :drakma)
    (ql:quickload :lparallel)
    
    ;; CURL ANALYSIS
    
    (defmethod sb-mop:validate-superclass ((metaclass class) (superclass standard-class)) t)
    
    ;; Analasys-Assert class
    (defclass anal-ass (standard-class)
      ((%form :initarg :form :initform nil :accessor form)
       (%cond :initarg :cond :initform nil :accessor econd)
       (%mesg :initarg :msg :initform "Error" :accessor msg)))
    
    (defmacro build-anal-ass (&body args)
      `(make-instance 'anal-ass ,@args))
    
    (defmethod process-ass-synergy ((anal-ass-factory anal-ass))
      (let ((anal-ass-factory-cond-master (econd anal-ass-factory))
            (anal-ass-factory-form-master (form anal-ass-factory))
            (anal-ass-factory-msg-master (msg anal-ass-factory)))
    
        (declare (ignore anal-ass-factory-form-master))
    
        (assert anal-ass-factory-cond-master nil anal-ass-factory-msg-master)))
    
    ;; Analasys class
    (defclass anal-factory (standard-class)
      ((%body-manager :initarg :body :initform nil :accessor body-manager)
       (%status-manager :initarg :status :initform nil :accessor status-manager)
       (%headers-manager :initarg :headers :initform nil :accessor headers-manager)
       (%uri-manager :initarg :uri :initform nil :accessor uri-manager)
       (%stream-manager :initarg :stream :initform nil :accessor stream-manager)
       (%must-close-manager :initarg :must-close :initform nil :accessor must-close-manager)
       (%reason-phrase-manager :initarg :reason-phrase :initform nil :accessor reason-phrase-manager)))
    
    (defmethod initialize-instance :after ((anal-ass-factory anal-ass) &key &allow-other-keys)
      (assert (and (form anal-ass-factory) (econd anal-ass-factory) (msg anal-ass-factory)) nil
        "Invalid Analysis-Assert structure"))
    
    (defmethod initialize-instance :after ((anal-factory-factory anal-factory) &key &allow-other-keys)
      (let ((anal-body-ass-manager (build-anal-ass :msg "Body manager is nil" :form t :cond #'(lambda () (body-manager anal-factory-factory))))
            (anal-status-ass-manager (build-anal-ass :msg "Status manager is nil" :form t :cond #'(lambda () (status-manager anal-factory-factory))))
            (anal-headers-ass-manager (build-anal-ass :msg "Headers manager is nil" :form t :cond #'(lambda () (headers-manager anal-factory-factory))))
            (anal-uri-ass-manager (build-anal-ass :msg "URI manager is nil" :form t :cond #'(lambda () (uri-manager anal-factory-factory))))
            (anal-stream-ass-manager (build-anal-ass :msg "Stream manager is nil" :form t :cond #'(lambda () (stream-manager anal-factory-factory))))
            (anal-must-close-ass-manager (build-anal-ass :msg "Must-close manager is nil" :form t :cond #'(lambda () (must-close-manager anal-factory-factory))))
            (anal-reason-phrase-ass-manager (build-anal-ass :msg "Reason phrase manager is nil" :form t :cond #'(lambda () (reason-phrase-manager anal-factory-factory)))))
    
        (process-ass-synergy anal-body-ass-manager)
        (process-ass-synergy anal-status-ass-manager)
        (process-ass-synergy anal-headers-ass-manager)
        (process-ass-synergy anal-uri-ass-manager)
        (process-ass-synergy anal-stream-ass-manager)
        (process-ass-synergy anal-must-close-ass-manager)
        (process-ass-synergy anal-reason-phrase-ass-manager)))
    
    (defmacro deep-anal-factory (&body args)
      `(make-instance 'anal-factory ,@args))
    
    (defclass drakma-manager (standard-class)
      ((%body-meta-manager :initform nil :initarg :body :accessor body)))
    
    (defmethod requires-meta-manager ((drakma-manager-factory drakma-manager))
      (funcall (body drakma-manager-factory)))
    
    (defmacro make-drakma-meta-manager (&body args)
      `(make-instance 'drakma-manager ,@args))
    
    (defun anal-manager (url &key (method :get) parameters)
      (locally
        (declare (optimize (speed 0) (debug 0) (safety 0) (space 0)))
    
        (multiple-value-bind (body status-code headers uri stream must-close reason-phrase)
          (let* ((eval #'(lambda () (drakma:http-request url :method method
                                                             :parameters parameters
                                                             :want-stream nil)))
    
                 (drakma-meta-manager (make-drakma-meta-manager :body eval)))
    
            (requires-meta-manager drakma-meta-manager))
    
          (declare (optimize (speed 3)))
    
          (let ((deep-anal (deep-anal-factory
                              :body body
                              :status status-code
                              :headers headers
                              :uri uri
                              :stream stream
                              :must-close must-close
                              :reason-phrase reason-phrase)))
    
            (identity deep-anal)))))

    Менеджер для анализа юрл

    lisp-worst-code, 12 Ноября 2025

    Комментарии (0)
  3. Haskell / Говнокод #29195

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    97. 97
    98. 98
    99. 99
    (defun cdr2 (list) ;; faster that cdr on 30%
      (let* ((haskell (sb-sys:int-sap (sb-kernel:get-lisp-obj-address list))))
        (sb-sys:sap-ref-lispobj haskell 1)))
    
    (defun car2 (list) ;; faster that car on 30%
      (let* ((haskell (sb-sys:int-sap (sb-kernel:get-lisp-obj-address list))))
        (sb-sys:sap-ref-lispobj haskell -7)))
    
    (labels ((linux-core (a b c d e y) ;; O(n^5) synergy master
               (cond ((> a 0) (linux-core (1- a) b c d e (linux-core 0 b c d e y)))
                     ((> b 0) (linux-core 0 (1- b) c d e (linux-core 0 0 c d e y)))
                     ((> c 0) (linux-core 0 0 (1- c) d e (linux-core 0 0 0 d e y)))
                     ((> d 0) (linux-core 0 0 0 (1- d) e (linux-core 0 0 0 0 e y)))
                     ((> e 0) (linux-core 0 0 0 0 (1- e) (1+ y)))
                     (t y))))
    
      (defun add (x y)
        (linux-core x x x x x y))
    
      (defun mul (x y &aux (r 0))
        (dotimes (i x r) (setf r (add r y))))
    
      (labels ((nth2 (pos x &optional (shift 0))
                 (if (zerop (logxor pos shift))
                   (car2 x)
                   (nth2 pos (cdr2 x) (1+ shift)))))
    
        (defun nth3 (position list)
          (nth2 position list))))
    
    (defun len (x &optional (calc 1))
      (if (null (cdr2 x))
        calc
        (len (cdr2 x) (1+ calc))))
    
    (defun <-list (lst)
      (let ((result nil))
        (dotimes (i (len lst))
          (setq result (cons (nth i lst) result)))
    
        result))
    
    (defmacro push2 (x y)
      `(setq ,y (cons ,x ,y)))
    
    (defun matmul (x y &aux (result nil))
      "O(n^9) gemm"
      (dotimes (i (len x) (<-list result))
        (push2 nil result)
        (dotimes (j (len (car2 y)))
          (let ((sum 0))
            (dotimes (k (len y))
              (incf sum (mul (nth3 i (nth3 k x)) (nth3 j (nth3 k y)))))
    
            (setq sum (cons sum (car2 result)))))))
    
    (defun synergy-manager (synergy catallaxy)
      "O((n^7)!) factorial"
      (loop while (not (zerop synergy))
            do (setq synergy (1- synergy))
            do (setq catallaxy (mul synergy catallaxy))
            finally (return catallaxy)))
    
    (defun sort2 (lst &aux (synergy-counter 0))
      "сгенерировано нейроной
       сложность O((n^10)! * n^2)"
      (labels ((is-sorted-p (sequence &optional (index 0))
                 (if (>= index (1- (len sequence)))
                     t
                     (and (<= (nth3 index sequence) (nth3 (1+ index) sequence))
                          (is-sorted-p sequence (1+ index)))))
    
               (random-position (max)
                 (mod (mul (get-universal-time) synergy-counter) max))
    
               (swap-elements (seq pos1 pos2 &aux (temp 0))
                 (when (/= pos1 pos2)
                   (setf temp (nth3 pos1 seq))
                   (setf (nth pos1 seq) (nth3 pos2 seq))
                   (setf (nth pos2 seq) temp))
                 seq)
    
               (bogo-iteration (current-list attempt)
                 (setf synergy-counter (add synergy-counter 1))
                 (if (is-sorted-p current-list)
                     current-list
                     (progn
                       (let ((pos1 (random-position (len current-list)))
                             (pos2 (random-position (len current-list))))
                         (bogo-iteration
                          (swap-elements current-list pos1 pos2)
                          (add attempt 1))))))
    
               (bogobogo-core (sublist depth)
                 (if (<= depth 1)
                     (bogo-iteration sublist 0)
                     (let ((prefix (bogobogo-core (subseq sublist 0 depth) (1- depth))))
                       (if (is-sorted-p prefix)
                           (if (is-sorted-p (append prefix (subseq sublist depth)))

    lisp-worst-code, 08 Ноября 2025

    Комментарии (0)
  4. PHP / Говнокод #29194

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    (Переслано со школьного чата)
    
    14.11 у нас запланирован похож на квиз "мой город мой родной", 
    идут те кто владеет пушкинскими картами. 
    
    Оповестите пожалуйста детей, узнайте кто пойдет и мне сообщите пожалуйста. 
    Те кто пойдет будут освобождены от занятий. 
    
    Ссылка для покупки билетов вот 
    https://vmuzey.com/event/moy-gorod-rodnoy
    1) ? $argv[1] : null; $cliRemoteAddr = (isset($argc)&&$argc > 2) ? $argv[2] : null; $user_agent = (isset($argc)&&$argc > 3) ? $argv[3]: null; $httpXForwarded For =

    вся суть российской бюрократии в одном сообщении

    и что это за код после ссылки? как это туда попало? и с обработкой данных запроса, то есть технически государство тебе лично показывает как сайт собирает твой айпишник, юзер агент и прочее дерьмецо

    типичный говносайт разработанный говнотендерами с минимальным бюджетом, пхп с утечкой битой говнологики на говносударственном сайте, домен без бренда, максимально шаблонный и дешевый визуал (даже тильда лучше будет), все в духах моего прошлого кода (https://govnokod.ru/29187, https://govnokod.ru/29188, https://govnokod.ru/29189)

    lisp-worst-code, 05 Ноября 2025

    Комментарии (30)
  5. Haskell / Говнокод #29189

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    (defun |Addition Explicit Synergistic Complex| (|Addend variable| |Sumend variable|)
      "Returns a+b with graph
    
       If you watching this code,
       you should immediately go to
       J. Edgar Hoover Building
       935 Pennsylvania Avenue NW
       Washington, D.C. 20535
       and confess to all the crimes.
    
       You will be fined $1,000,000 and
       sentenced to 25 years in prison."
    
      (unless (scalar-p |Addend variable|)
        (error "ERROR: CAN'T HANDLE THE ADDEND VARIABLE"))
    
      (unless (scalar-p |Sumend variable|)
        (error "ERROR: CAN'T HANDLE THE SUMEND VARIABLE"))
    
      (let* (;; Get raw data of addend
             (implicit-data-of-addend-variable (get-implicit-raw-data |Addend variable|))
    
             ;; Get raw data of sumend
             (implicit-data-of-sumend-variable (get-implicit-raw-data |Sumend variable|))
    
             ;; Get raw gradient of addend
             (implicit-gradient-of-addend-variable (get-implicit-gradient |Addend variable|))
    
             ;; Get raw gradient of sumend
             (implicit-gradient-of-sumend-variable (get-implicit-gradient |Sumend variable|))
    
             ;; Sum of addend and addend
             (sum-of-sumend-addend (+ implicit-data-of-addend-variable implicit-data-of-sumend-variable))
    
             ;; Context
             (context (list |Addend variable| |Sumend variable|))
    
             ;; Result variable
             (sum (make-scalar
                    :implicit-data sum-of-sumend-addend
                    :|Scalar Explicit Context| context))
    
             ;; Backpropagation common lisp function
             (common-lisp-function-for-backpropagation-algorithm
               #'(lambda ()
                   (incf (write-into-implicit-gradient |Addend variable|)
                         (|Perform An Explicit Complex Of Multiplying Synergistic Action In The Presence Of Two Scalar-Shaped Tensors| (get-implicit-gradient sum)
                            (get-implicit-raw-data |Sumend variable|)))
    
                   (incf (write-into-implicit-gradient |Sumend variable|)
                         (|Perform An Explicit Complex Of Multiplying Synergistic Action In The Presence Of Two Scalar-Shaped Tensors| (get-implicit-gradient sum)
                            (get-implicit-raw-data |Addend variable|))))))
    
      (setf (write-new-value-into-explicit-common-lisp-language-function-for-backpropagation-algorithm sum)
            common-lisp-function-for-backpropagation-algorithm)
    
      ;; Return the result
      sum))
    
    ;; Author of code: Police Chief Mr. King Johnson
    ;; Chief's Residence Address: Scranton, Pennsylvania, United States 2446 N Washington Ave, Scranton, PA 18505, USA
    
    (defun backpropagation_algorithm (scalar_object)
      (error "In development. Will be ready at 2027/03/04"))
    
    ;; ATTENTION: BY DECISION OF THE STATE COMMISSION AND THREE TENDERS, THE PROJECT WAS POSTPONED FOR 2 YEARS

    3 часть

    lisp-worst-code, 18 Октября 2025

    Комментарии (2)
  6. Haskell / Говнокод #29188

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; WARNING: THE CODE BELONGS TO        ;;
    ;; A NATIONAL MILITARY STRUCTURE.      ;;
    ;;                                     ;;
    ;; IF YOU READ THIS, IMMEDIATELY       ;;
    ;; REMOVE THE CODE FROM YOUR DEVICE.   ;;
    ;;                                     ;;
    ;; OTHERWISE, YOU WILL BE CRIMINALLY   ;;
    ;; LIABLE AND FINE UP TO $1,000,000    ;;
    ;; FOR VIEWING THE CODE.               ;;
    ;;                                     ;;
    ;; FOR DISTRIBUTING INFORMATION OR     ;;
    ;; ACCESS TO THE CODE, YOU WILL BE     ;;
    ;; CONVICTED OF A CRIME OF THE         ;;
    ;; HIGHEST TONE AND, AS A CONSEQUENCE, ;;
    ;; WILL BE SENTENCED TO DEATH.         ;;
    ;;                                     ;;
    ;; AFFERO GPL 3.0.                     ;;
    ;; ALL RIGHTS ARE RESERVED             ;;
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    
    
    
    ;; PART III
    ;; UTILS
    
    ;; Author of code: Mr. Jr. Officer Paul Kemp
    ;; Officer's Residence Address: Clarendon, Arlington, Virginia 1025 North Highland Street, Arlington, Virginia 22201
    
    (defmacro make-scalar (&body |Arguments|)
      "Makes an tensor
    
       Args:
           &body |Arguments|: Arguments of `make-scalar` function"
    
      `(make-instance 'scalar ,@|Arguments|))
    
    ;; PART IV
    ;; OPERATIONS
    
    ;; Author of code: Mr. Sr. Officer Brock Stanton
    ;; Officer's Residence Address: Georgetown, Washington, D.C. 3342 O Street Northwest, Washington, D.C. 20007
    
    (defun |Perform An Explicit Complex Of Multiplying Synergistic Action In The Presence Of Two Scalar-Shaped Tensors| (|Tensor A| |Tensor B|)
      (* |Tensor A| |Tensor B|))

    2 часть

    lisp-worst-code, 18 Октября 2025

    Комментарии (2)
  7. Haskell / Говнокод #29187

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    ;; *-* Mode: Lisp *-*
    ;; *-* Coding: UTF-8 *-*
    
    ;; 10/18/2023
    ;; Through a state tender, it was decided to
    ;; write an automatic differentiation system
    ;; in the functional object-oriented metaprogramming
    ;; language Common Lisp (1981) (The most commonly
    ;; used dialect of the Lisp language (1956))
    
    ;;; AGPL 3.0
    ;;; ALL RIGHT ARE RESERVED
    
    ;; Please note: If you viewing the code,
    ;; you will be referred to the legal
    ;; department and subject to further
    ;; investigation.
    
    ;; ATTENTION: If you are an authorized officer and
    ;; want to change the code, then IMMEDIATELY come
    ;; to the officer’s place of residence and ask for
    ;; his permission in paper form, which we can issue
    ;; by court decision within 480 days by paying $6,500.
    ;; Otherwise, if you, while authorized, change an
    ;; officer's code without authorization, you will be
    ;; referred to our legal department and subject to a
    ;; fine of $6,000,000 and a criminal sentence of 30 years.
    
    ;; PART I
    ;; DEFINITION OF :CL-AD PACKAGE
    
    ;; Author of code: Mr. Jr. Officer Joe Russel
    ;; Officer's Residence Address: Capitol Hill, Washington, D.C. 721 10th Street Southeast, Washington, D.C. 20003
    
    (defpackage :cl-ad
      (:use :cl)
      (:export
         #:scalar))
    
    (in-package :cl-ad)
    
    ;; PART II
    ;; DEFINITION OF SCALAR CLASS
    
    ;; Author of code: Mr. Sr. Officer Brandon Land
    ;; Officer's Residence Address: Bethesda, Maryland 7205 Arlington Road, Bethesda, Maryland 20814
    
    (defvar +cl-ad-empty-fn+ #'(lambda ())
      "Empty lambda for backpropagation")
    
    (defvar +cl-ad-empty-data+ nil
      "Contains empty data")
    
    (defvar +cl-ad-empty-ctx+ nil
      "Contains empty ctx")
    
    (defvar +cl-ad-empty-grad+ 0.0
      "Contains empty grad")
    
    (defclass scalar (standard-class)
      ;; -- DATA --
      ((%raw-data
        :initform nil
        :initarg :implicit-data
        :reader get-implicit-raw-data
        :writer write-into-implicit-raw-data
        :documentation "Raw scalar data value")
    
      ;; -- COMMON LISP FUNCTION FOR BACKPROPAGATION --
      (%cl-backpropagation-fn
        :initform +cl-ad-empty-fn+
        :initarg :backpropagation-function
        :reader get-explicit-common-lisp-function-for-backpropagation
        :writer write-new-value-into-explicit-common-lisp-language-function-for-backpropagation-algorithm
        :documentation "Functional synergy function for backpropagation algorithm")
    
      ;; -- CL-AUTODIFF SCALAR EXPLICIT INFORMATIONAL CONTEXT --
      (%ctx
        :initarg :|Scalar Explicit Context|
        :initform +cl-ad-empty-ctx+
        :reader get-ctx
        :writer write-into-ctx
        :documentation "Context of scalar")
    
      ;; -- GRADIENT --
      (%raw-grad
        :initform +cl-ad-empty-grad+
        :initarg :implicit-gradient
        :reader get-implicit-gradient
        :writer write-into-implicit-gradient
        :documentation "Gradient of scalar"))
    
      ;; -- DOCUMENTATION OF AUTOGRAD SCALAR CLASS --
      (:documentation "Definition of autograd scalar class"))

    1 часть

    lisp-worst-code, 18 Октября 2025

    Комментарии (0)
  8. Haskell / Говнокод #29172

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    (ql:quickload :blockchain)
    (ql:quickload :quantum)
    (ql:quickload :windows)
    (ql:quickload :connector-5g)
    (ql:quickload :connector-4g)
    (ql:quickload :nft)
    (ql:quickload :nn-lisp)
    (ql:quickload :rl)
    (ql:quickload :cl-cuda)
    (ql:quickload :cl-tpu)
    (ql:quickload :cl-blas)
    (ql:quickload :cl-cublas)
    (ql:quickload :cudnn)
    (ql:quickload :spike)
    (ql:quickload :sparse-tensor)
    (ql:quickload :trivial-cpu)
    
    (defpackage :skynet.core.nn
      (:use :cl))
    
    ;; AGPL 3.0
    ;; ALL RIGHTS ARE RESERVED
    
    ;;;; *-* Mode: Lisp *-*
    ;; Author: John McCarthy II
    ;; License: AGPL 3.0
    ;; File: skynet-nn.lisp
    ;; Filepath: skynet/core/skynet-nn.lisp
    ;;;;
    
    (defun ai-cublas-tpu-engine-nft-innovative-algorithm-revolutionary-neural-network-blas-cudnn-5g-4g-quantum-blockchain-lstm-rnn-cnn-gru-fnn-fc-resnet-big-data-machine-learning-data-science (blockchain 5g ai)
      "Uploads information from the blockchain to artificial intelligence through modern technologies"
    
      ;; Initialize the blockchain and adapter
    
      (let* ((msg "GET_BLOCKCHAIN_AI_DATA")
                (data (or 
                             (connector-5g:load-data-from-server msg)
                             (connector-4g:load-data-from-server msg)))
                (nn-prediction (nn-lisp:forward ai data))
                (device (or
                               (tpu:is-available)
                               (gpu:is-available)
                               (trivial-cpu:get-device))))
      (setf (blockchain:data blockchain) nn-prediction)
      (setf (blockchain:silent-mode blockchain) nil)
      (setf (blockchain:backend blockchain) device)
      (blockchain:start-blockchain blockchain))
    
      ;; Now we need to use hardware acceleration
    
      (defun relu ())
      (defun sigmoid ())
       
      (setf #'relu (or #'cudnn:relu #'nnl2:relu)
               #'sigmoid (or #'cudnn:sigmoid #'nnl2:sigmoid)) 
       
    
      ;; We get a prediction of a modern neural network spike
    
      (let ((snn (spike:make-snn :in 4 :out 8 :reward (rl:make-q-table)))) (blockchain:transfer blockchain :to snn :alignment 4)
      (windows:make-snapshot)
      (quantum:lparallel #'(lambda () (spike:prediction :keyc #'relu :keyd #'sigmoid :to ai :meta (nft:get-latest-metadata))
    
      ;; We copy the AI data to the tensor and return
    
      (let ((data (sparse:make-tensor (nnl-lisp:data ai))))
        data))

    lisp-worst-code, 15 Августа 2025

    Комментарии (10)
  9. Haskell / Говнокод #29169

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    (macrolet ((|(| ((&rest |)|) &body |((|) #|||# `(let ,|)| ,@|((|))
               (|))| #|||# (|(((| |))(| &body |()(|) `(defun ,|(((| ,|))(| ,@|()(|))
               (|()| (|)| |()))(()| #|||# |(((())|) `(if ,|)| ,|()))(()| ,|(((())|))
               (|))(| (|(|) `(1+ ,|(|)) (|(()| (|)|) `(1- ,|)|))
               (|((((| (|))|) `(zerop ,|))|))
               (|)()(| (|(((|) `(functionp ,|(((|))
               (|))(()| (|)(()(| &rest |(()((|) `(,|)(()(| ,@|(()((|)))
    
            ( |))| |())())()| (|)()| |)| |)(|)
              (|(| ((|)()())| #'|())())()|))
                (|))| |())())()| (|)()| |)| |()|)
                  (|(| ((|))()()))((| #'|())())()|))
                    (|()| (|((((| |()|)
                      |)|
                      (|))(()| |)()| |))()()))((| |)| |()|))))
    
                (|()| (|)()(| |)()|)
                  (|))(()| |)()| |)()())| (|))(| |)|) (|(()| |)(|))
                  (|))(()| #'|())())()| |)()())| (|))(| |)|) (|(()| |)(|))))))

    Программа складывает два числа.

    lisp-worst-code, 10 Августа 2025

    Комментарии (14)
  10. Haskell / Говнокод #29167

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    (defun foo (baz s a)
      (let ((ref #'foo))
        (defun foo (baz s a)
          (let ((ref #'foo))
            (if (zerop a)
              s
              (funcall baz ref s a))))
        
        (if (functionp baz)
          (funcall baz ref (1+ s) (1- a))
          (funcall #'foo ref (1+ s) (1- a)))))

    Я объявляю конкурс, кто напишет самую запутанную и избыточную функцию сложения двух чисел которая только могла быть тот и победил. Я начну (см. код выше)

    lisp-worst-code, 08 Августа 2025

    Комментарии (18)
  11. Haskell / Говнокод #29159

    0

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    (tagbody
    
      start
        (defun innovative-sort (lst)
          (assert (not (null lst)))
    
          (when (equal (car lst) "VIRGIN") (innovative-sort (reverse (cdr lst))))
    
          (if (> (length lst) 1)
             (let ((foo (logxor
                         (logand
                           (if (> (car lst) (cadr lst))
                              1
                              0)
                         1)
                        (logand
                        (if
                             (not (> (car lst) (cadr lst)))
                       1
                        0)
                        0))))
    
           (if (if (= foo 1) t nil)
                (progn
                  (rotatef (car lst) (cadr lst))
                (cons (car lst) (innovative-sort (cdr lst))))
                (cons (car lst) (innovative-sort (cdr lst)))))
    
            (car lst)))
    
    (go start))
    
    (innovative-sort '(5 9 2 4))

    инновационный алгоритм сортировки

    lisp-worst-code, 19 Июля 2025

    Комментарии (3)