Вопрос про ООП (программистам)

Всё что НЕ касается магии, эзотерики, духовного роста и сопутствующим им темам, размещать только здесь. Подфорум вне эгрегора клуба.

Модератор: Дейра

Аватара пользователя
Z
Участник Клуба
Участник Клуба
Сообщения: 6472
Зарегистрирован: 26 июл 2009 08:48
Обучение магии, это:: Жизнь. Ты можешь это принять или это отрицать, но ты всё равно учишься. Быстро или медленно, твой выбор только в этом.
Откуда: Томск
Благодарил (а): 601 раз
Поблагодарили: 474 раза
Контактная информация:

Сообщение Z » 27 мар 2014 20:07

Вообще интересно.. Особенно мне понравилась потенциальная возможность оперировать без конечными значениями.. Но вопрос зачем? Любой язык в конце концов создаётся для чего то.. Так вот зачем в конечном мире, возможность оперировать без конечными объектами? Для большинства людей беЗконечность это очень сложно. Поэтому когда в описании языка говорится о том, что это очень «простой и удобный язык», мне хочется спросить для кого? Для математиков работающих с абстракциями.. Может быть.. И возможно когда нибудь это станет востребованным.

Что касается его эффективности на данный момент.
Подобным образом на Haskell многие алгоритмы можно записать гораздо короче, нежели на Си


Что то мне подсказывает, о существовании и обратного эффекта. Какие то простые конструкции на Си, будут очень сложно выглядеть на Хацкале.

Помню нам в институте давали какой то «супер язык» для решения и эмуляции транспортных задач и цепочек поставок. Да тоже было достаточно интересно.. Но сейчас я даже названия этого языка не помню, хотя ему тоже пророчили большое будущее.

Если говорить о магическом восприятии достаточно сложно, потому что я не знаю этого языка.. Могу сказать исходя из моих более чем поверхносных представлений о нём. Описание абстракций, не даёт понимания того как это устроено. (А ООП, даёт именно это понимание). Да работа с абстракциями может отражать магическую работы, но это лишь частный случай.. Все же остальные это отражение иллюзий.
Свет всегда светит и все освещает, научись принять его, и сам будешь свет..

Аватара пользователя
Амонар
Сообщения: 2440
Зарегистрирован: 19 ноя 2010 20:02
Благодарил (а): 13 раз
Поблагодарили: 131 раз
Контактная информация:

Сообщение Амонар » 01 апр 2014 21:53

Zemius писал(а):Особенно мне понравилась потенциальная возможность оперировать без конечными значениями.. Но вопрос зачем? Любой язык в конце концов создаётся для чего то.. Так вот зачем в конечном мире, возможность оперировать без конечными объектами?

Ну там же написано зачем. В ленивых вычислениях бесконечность это то же самое, что и рекурсивная функция, только выраженная, на мой взгляд, более красиво и показательно.

Zemius писал(а):Поэтому когда в описании языка говорится о том, что это очень «простой и удобный язык», мне хочется спросить для кого? Для математиков работающих с абстракциями..

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

В императивных языках программирования нам предлагаются следующие абстракции: цикл, переменная, функция или процедура и т.д., плюс основные структуры данных. В ООП добавляется класс, наследование и различные штуки для удобства организации программного кода. В принципе, вот и всё, что есть.

Функциональное программирование дает много разных более тонкий идей родом из математики и позволяет строить алгоритмы с помощью них. Сложность не рассматриваем - допустим все у нас математики (на мой взгляд так и должно в программировании быть). С точки зрения алгоритмики все супер. Кроме этого нас интересует читаемость кода, эффективная организация кода в больших проектах и масштабируемость. C читаемостью вроде бы все не плохо:
обучение магии вот пример ftp клиента - задача, далекая от алгоритмов

Код: Выделить всё

{-# LANGUAGE FlexibleInstances #-}

module Main (main) where
import Data.Maybe
import qualified Data.Strict.Maybe as Strict
import Control.Monad.State.Strict
import System.Console.Haskeline hiding (getInputLine)
import qualified System.Console.Haskeline as Haskeline
       (getInputLine)
import Network.Socket hiding (connect)
import Network.FTP.Client
import Network.FTP.Client.Parser
import System.Directory
import Control.Applicative ((<$>))
import Data.List (intercalate)
import System.Console.ANSI
import System.IO
import System.Environment (getArgs)
import qualified Data.ByteString.Char8 as B
import Paths_FTPLine (version)
import Data.Version (showVersion)
 
ftperror :: String -> FTPLine a
ftperror = liftIO . fail
 
getInputLine :: String -> FTPLine String
getInputLine str
  = do withColor Yellow $ outputStr str
       ms <- Haskeline.getInputLine "\n"
       if ms == Nothing then
         do withColor Green $ outputStrLn "Switching local/remote..."
            return "switch"
         else return $ fromJust ms
 
getInputLine_ :: String -> String -> FTPLine ()
getInputLine_ str com
  = do withColor Yellow $ outputStr str
       outputStrLn com
 
data File = File FilePath !B.ByteString
 
type SMaybe = Strict.Maybe
 
data FTPState = FTPState{conn :: Maybe FTPConnection,
                         file :: !(SMaybe File), host :: Maybe String, mode :: Bool,
                         interactive :: Bool}
 
boolToMode :: Bool -> String
boolToMode b = if b then "Remote" else "Local"
 
initialFTPState :: FTPState
initialFTPState
  = FTPState{conn = Nothing, file = Strict.Nothing, host = Nothing,
             mode = False, interactive = False}
 
type FTPLine a = InputT (StateT FTPState IO) a
 
getting ::
          (MonadState st m, MonadTrans t, Functor (t m)) =>
          (st -> x) -> t m x
getting f = f <$> lift get
 
modif :: (MonadTrans t, MonadState s m) => (s -> s) -> t m ()
modif = lift . modify
 
getConnection :: FTPLine (Maybe FTPConnection)
getConnection = getting conn
 
newConnection :: String -> FTPConnection -> FTPLine ()
newConnection hn c
  = modif $
      \ (FTPState _ mf _ b i) -> FTPState (Just c) mf (Just hn) b i
 
removeConnection :: FTPLine ()
removeConnection
  = modif $
      \ (FTPState _ mf _ b i) -> FTPState Nothing mf Nothing b i
 
getFile :: FTPLine (SMaybe File)
getFile = getting file
 
newFile :: File -> FTPLine ()
newFile f
  = modif $!
      \ (FTPState mc _ md b i) -> FTPState mc (Strict.Just f) md b i
 
cleanFile :: FTPLine ()
cleanFile
  = modif $!
      \ (FTPState mc _ md b i) -> FTPState mc Strict.Nothing md b i
 
getHost :: FTPLine String
getHost
  = return "Local" <-> const (getting $ maybe "Local" id . host)
 
getMode :: FTPLine Bool
getMode = getting mode
 
turnMode :: FTPLine ()
turnMode = modif $ \ s -> s{mode = not $ mode s}
 
isInteractive :: FTPLine Bool
isInteractive = getting interactive
 
setInteractive :: Bool -> FTPLine ()
setInteractive b = modif $ \ s -> s{interactive = b}
 
connect :: HostName -> PortNumber -> FTPLine FTPResult
connect hn pn
  = do mc <- getConnection
       if isNothing mc then return () else
         (liftIO $ quit $ fromJust mc) >> return ()
       (c, r) <- liftIO $ connectFTP hn pn
       newConnection hn c
       saveConnection hn pn
       return r
 
saveConnection :: HostName -> PortNumber -> FTPLine ()
saveConnection hn pn
  = do appDir <- liftIO ftpLineDir
       liftIO $ writeFile (appDir ++ "/LastConnection") $ show (hn, pn)
 
withConnection :: (FTPConnection -> FTPLine a) -> FTPLine a
withConnection f
  = do mc <- getConnection
       if isNothing mc then ftperror "Connection not established." else
         f $ fromJust mc
 
saveLogin :: String -> String -> FTPLine ()
saveLogin name pass
  = do appDir <- liftIO ftpLineDir
       liftIO $ writeFile (appDir ++ "/LastLogin") $ show (name, pass)
 
ftplogin :: Maybe (String, String) -> FTPLine FTPResult
ftplogin Nothing = withConnection $ liftIO . loginAnon
ftplogin (Just (name, pass))
  = do r <- withConnection $
              \ c -> liftIO $ login c name (Just pass) Nothing
       saveLogin name pass
       return r
 
lastConn :: FTPLine ()
lastConn
  = hand
      (const $
         withColor Red $ outputStrLn "Last connection doesn't exist.")
      $
      do appDir <- liftIO ftpLineDir
         lc <- liftIO $ readFile $ appDir ++ "/LastConnection"
         _ <- (liftIO $ readIO lc) >>= uncurry connect
         outputStrLn "Last connection reestablished."
         hand
           (const $ withColor Red $ outputStrLn "Last login doesn't exist.")
           $
           do ll <- liftIO $ readFile $ appDir ++ "/LastLogin"
              _ <- (liftIO $ readIO ll) >>= ftplogin . Just
              outputStrLn "Last login reestablished."
 
disconnect :: FTPLine FTPResult
disconnect
  = withConnection $
      \ c ->
        do removeConnection
           liftIO $ quit c
 
ftpdebug :: FTPLine ()
ftpdebug = liftIO enableFTPDebugging
 
success :: FTPResult
success = (1, ["Success"])
 
failure :: FTPResult
failure = (0, ["Failure"])
 
showFTPResult :: FTPResult -> String
showFTPResult (n, xs) = unwords $ [show n, ":"] ++ xs
 
outputFTPResult :: FTPResult -> FTPLine ()
outputFTPResult = withColor Magenta . outputStrLn . showFTPResult
 
discardConnection :: FTPLine Bool
discardConnection
  = do mc <- getConnection
       b <- getMode
       return $ not b || isNothing mc
 
(<->) :: FTPLine a -> (FTPConnection -> FTPLine a) -> FTPLine a
la <-> ra
  = do b <- discardConnection
       if b then la else
         do mc <- getConnection
            ra $ fromJust mc
 
localdir :: Maybe String -> FTPLine ()
localdir fp
  = if isNothing fp then
      liftIO (getDirectoryContents ".") >>= mapM_ outputStrLn . reverse
      else
      liftIO (getDirectoryContents $ fromJust fp) >>= mapM_ outputStrLn
 
pdir :: Maybe String -> FTPLine ()
pdir fp
  = localdir fp <-> \ c -> liftIO (dir c fp) >>= mapM_ outputStrLn
 
getfile :: String -> FTPLine FTPResult
getfile fp
  = (do x <- liftIO $ B.readFile fp
        newFile $ File fp x
        return success)
      <->
      \ c ->
        do (x, r) <- liftIO $ getbinary c fp
           newFile $ File fp $ B.pack x
           return r
 
download :: String -> FTPLine FTPResult
download fp = withConnection $ \ c -> liftIO $ downloadbinary c fp
 
putfile :: String -> FTPLine FTPResult
putfile fp
  = (do x <- getFile
        if Strict.isNothing x then ftperror "File memory empty." else
          let (File _ cnt) = Strict.fromJust x in
            do liftIO $ B.writeFile fp cnt
               return success)
      <->
      \ c ->
        do x <- getFile
           if Strict.isNothing x then ftperror "File memory empty." else
             let (File _ cnt) = Strict.fromJust x in
               liftIO $ putbinary c fp $ B.unpack cnt
 
upload :: String -> FTPLine FTPResult
upload fp = withConnection $ \ c -> liftIO $ uploadbinary c fp
 
renamefile :: String -> String -> FTPLine FTPResult
renamefile fp1 fp2
  = (do liftIO $ renameFile fp1 fp2
        return success)
      <-> \ c -> liftIO $ rename c fp1 fp2
 
deletefile :: String -> FTPLine FTPResult
deletefile fp
  = (do liftIO $ removeFile fp
        return success)
      <-> \ c -> liftIO $ delete c fp
 
sizefile :: String -> FTPLine FTPResult
sizefile fp
  = do n <- (liftIO $ B.length <$> B.readFile fp) <->
              \ c -> liftIO $ size c fp
       outputStrLn $ show n
       return success
 
ccd :: String -> FTPLine FTPResult
ccd fp
  = (do liftIO $ setCurrentDirectory fp
        return success)
      <-> \ c -> liftIO $ cwd c fp
 
newdir :: String -> FTPLine FTPResult
newdir fp
  = (do liftIO $ createDirectory fp
        return success)
      <-> \ c -> liftIO $ snd <$> mkdir c fp
 
remdir :: String -> FTPLine FTPResult
remdir fp
  = (do liftIO $ removeDirectory fp
        return success)
      <-> \ c -> liftIO $ rmdir c fp
 
curdir :: FTPLine (Maybe String, FTPResult)
curdir
  = (do x <- liftIO getCurrentDirectory
        return (Just x, success))
      <-> (liftIO . pwd)
 
class (Read a) => Arg a where
   parse :: String -> FTPLine a
   parse = liftIO . readIO
 
output :: (Show a) => a -> FTPLine ()
output = outputStrLn . show
 
command :: String -> FTPLine ()
command str
  = if null xs then outputStrLn "No command introduced." else
      withColor Green $ runCom (head xs) (tail xs)
  where xs = separgs str
 
printHelp :: String -> FTPLine ()
printHelp str
  = withColor Cyan $
      mapM_
        (\ ln ->
           if head ln == '*' then outputStrLn ln else
             italized $ outputStrLn ln)
        $ commandDesc str
 
hand :: (MonadException m) => (IOException -> m a) -> m a -> m a
hand = handle
 
handres :: FTPLine FTPResult -> FTPLine ()
handres c
  = hand ((>> return failure) . withColor Red . output) c >>=
      outputFTPResult
 
hand_ :: FTPLine () -> FTPLine ()
hand_ = hand (withColor Red . output)
 
inEchoOff, inEchoOn :: FTPLine ()
inEchoOff = liftIO $ hSetEcho stdin False
inEchoOn = liftIO $ hSetEcho stdin True
 
runCom :: String -> [String] -> FTPLine ()
runCom str ["help"] = printHelp str
runCom "help" _
  = do withColor Cyan $ outputStrLn helpHead
       mapM_ printHelp commands
runCom "connect" args = handres $ mkCom args $ uncurry connect
runCom "login" args
  = do isInt <- isInteractive
       if isInt then
         do let isAnon
                  = do withColor Yellow $ outputStr "Login as anonymous? (y/n) "
                       c <- getInputChar ""
                       case c of
                           Just 'y' -> return True
                           Just 'n' -> return False
                           _ -> do liftIO $
                                     do cursorUpLine 1
                                        clearFromCursorToScreenEnd
                                   isAnon
            b <- isAnon
            if b then handres $ withColor Green $ ftplogin Nothing else
              do withColor Yellow $ outputStr "User name: "
                 name <- Haskeline.getInputLine ""
                 withColor Yellow $ outputStr "Password : "
                 pass <- getPassword (Just '*') ""
                 if isNothing name || isNothing pass then
                   outputStrLn "Incorrect login." else
                   handres $
                     withColor Green $ ftplogin $ Just (fromJust name, fromJust pass)
         else
         if null args then handres $ ftplogin Nothing else
           handres $ mkCom args $ ftplogin . Just
runCom "disconnect" _ = handres disconnect
runCom "ftpdebug" _ = ftpdebug
runCom "dir" args
  = if null args then hand_ $ pdir Nothing else
      hand_ $ mkCom args $ pdir . Just
runCom "getfile" args = handres $ mkCom args $ getfile
runCom "download" args = handres $ mkCom args $ download
runCom "putfile" args = handres $ mkCom args $ putfile
runCom "upload" args = handres $ mkCom args $ upload
runCom "rename" args = handres $ mkCom args $ uncurry renamefile
runCom "delete" args = handres $ mkCom args $ deletefile
runCom "size" args = handres $ mkCom args $ sizefile
runCom "cd" args = handres $ mkCom args $ ccd
runCom "md" args = handres $ mkCom args $ newdir
runCom "rd" args = handres $ mkCom args $ remdir
runCom "clear" _
  = do hand_ cleanFile
       outputStrLn "Memory Cleared."
runCom "pause" _
  = do outputStr "PAUSE. Press ENTER to continue..."
       inEchoOff
       _ <- liftIO $ getLine
       inEchoOn
       outputStrLn ""
runCom "switch" _
  = do turnMode
       b <- getMode
       outputStrLn $ "Current mode: " ++ boolToMode b
runCom "last" _ = lastConn
runCom x _
  = withColor Cyan $ outputStrLn $ "Command doesn't exist: " ++ x
 
commands :: [String]
commands
  = ["connect", "disconnect", "login", "ftpdebug", "last", "dir",
     "cd", "md", "rd", "getfile", "putfile", "clear", "download",
     "upload", "rename", "delete", "size", "switch", "pause", "exit"]
 
helpHead :: String
helpHead
  = unlines
      ["", "Below is a list of available commands.",
       "Arguments in brackets are optional.",
       "Arguments in braces are only used in batch mode."]
 
commandDesc :: String -> [String]
commandDesc "connect"
  = ["connect HostName Port", "* Connect to remote FTP server."]
commandDesc "login"
  = ["login {[UserName Password]}", "* Login to the FTP server."]
commandDesc "disconnect"
  = ["disconnect", "* Close the current conection."]
commandDesc "ftpdebug"
  = ["ftpdebug", "* Enable logging of FTP messages."]
commandDesc "dir"
  = ["dir [FilePath]", "* Show a directory content."]
commandDesc "getfile"
  = ["getfile FilePath",
     "* Load specified file and save its content in a temporal memory."]
commandDesc "download"
  = ["download FilePath", "* Download a remote file to your system."]
commandDesc "putfile"
  = ["putfile FilePath",
     "* Write a file with the temporal memory's content."]
commandDesc "upload"
  = ["upload FilePath", "* Upload a file from disk."]
commandDesc "rename"
  = ["rename FilePath1 FilePath2", "* Rename a file."]
commandDesc "delete" = ["delete FilePath", "* Delete a file."]
commandDesc "size"
  = ["size FilePath", "* Return the size of a file."]
commandDesc "cd"
  = ["cd FilePath", "* Change the current directory."]
commandDesc "md" = ["md FilePath", "* Create a new directory."]
commandDesc "rd" = ["rd FilePath", "* Remove a directory"]
commandDesc "exit" = ["exit", "* Close the client."]
commandDesc "clear" = ["clear", "* Clear the temporal memory."]
commandDesc "pause"
  = ["pause", "* Stop the program until pressing ENTER.",
     "* Useful for FTP batch programs."]
commandDesc "switch"
  = ["switch", "* Switch between local and remote mode.",
     "* CTRL+D invokes this action."]
commandDesc "last"
  = ["last",
     "* Try to connect and login as it was done the last time."]
commandDesc _ = ["* Invalid command."]
 
mkCom :: (Arg a) => [String] -> (a -> FTPLine b) -> FTPLine b
mkCom [] _ = ftperror "Need more arguments."
mkCom args f
  = if length args > 1 then
      parse (concat ["(", intercalate "," args, ")"]) >>= f else
      parse (head args) >>= f
 
instance Arg [Char] where
        parse = return
 
instance Read PortNumber where
  readsPrec n str = (\(x,r) -> ((fromIntegral :: Int -> PortNumber) x , r)) <$> readsPrec n str
 
safeTail :: [a] -> [a]
safeTail [] = []
safeTail (_:xs) = xs

instance (Arg a, Arg b) => Arg (a, b) where
        parse str
          = let str' = init . tail $ str
                xs = takeWhile (/= ',') str'
                ys = safeTail $ dropWhile (/= ',') str'
              in
              do x <- parse xs
                 y <- parse ys
                 return (x, y)
 
instance Arg PortNumber where
  parse str = liftIO $ readIO str
 
addChar :: Char -> [String] -> [String]
addChar c [] = [[c]]
addChar c (x : xs) = (c : x) : xs
 
args' :: String -> [String] -> Bool -> [String]
args' [] xs _ = xs
args' (x : xs) ys b
  | x == ' ' =
    if b then args' xs (addChar x ys) b else args' xs ([] : ys) b
  | x == '"' = args' xs ys $ not b
  | otherwise = args' xs (addChar x ys) b
 
separgs :: String -> [String]
separgs str = reverse $ reverse <$> args' str [] False
 
withSGR :: (MonadIO m) => [SGR] -> [SGR] -> m a -> m a
withSGR xs ys comp
  = do liftIO $ setSGR xs
       x <- comp
       liftIO $ setSGR ys
       return x
 
withColor :: (MonadIO m) => Color -> m a -> m a
withColor col
  = withSGR [SetColor Foreground Vivid col]
      [SetColor Foreground Vivid White]
 
italized :: (MonadIO m) => m a -> m a
italized
  = withSGR [SetSwapForegroundBackground True]
      [SetSwapForegroundBackground False]
 
ftpLineDir :: IO FilePath
ftpLineDir = getAppUserDataDirectory "FTPLine"
 
main :: IO ()
main
  = do setSGR [SetColor Foreground Vivid White]
       args <- getArgs
       appDir <- ftpLineDir
       createDirectoryIfMissing True appDir
       putStrLn $ "*** Welcome to FTPLine " ++ showVersion version ++ " ***"
       if null args then
         withColor Cyan $
           do putStr "Type "
              italized $ putStr "help"
              putStrLn " for a list of commands."
              let sets
                    = defaultSettings{historyFile = Just $ appDir ++ "/History"}
              evalStateT (runInputT sets mainInteractive) initialFTPState
         else
         do let arg = head args
            exst <- doesFileExist arg
            if exst then
              do txt <- readFile arg
                 evalStateT
                   (runInputT defaultSettings $
                      mapM_
                        (\ str ->
                           do (mcd, hn) <- withColor Green $
                                             do mcd <- hand
                                                         ((>> (return $ Just "?")) .
                                                            withColor Red . output)
                                                         $ fst <$> curdir
                                                hn <- getHost
                                                return (mcd, hn)
                              let cd = if isNothing mcd then "? " else fromJust mcd
                              getInputLine_ (unwords [cd, "@", hn ++ ">>\n"]) str
                              hand_ $ command str)
                        $ lines txt ++ ["disconnect"])
                   initialFTPState
                 putStrLn "Closing FTPLine."
              else withColor Red $ putStrLn $ "File " ++ arg ++ " doesn't exist."
       setSGR [Reset]
 
mainInteractive :: FTPLine ()
mainInteractive
  = do setInteractive True
       runCicle
 
runCicle :: FTPLine ()
runCicle
  = hand
      (\ e ->
         do withColor Red $ output e
            ln <- getInputLine "? >>"
            if ln == "exit" then exit else
              do hand_ $ command ln
                 runCicle)
      mainCicle
 
mainCicle :: FTPLine ()
mainCicle
  = do (mcd, hn) <- withColor Green $
                      do mcd <- hand
                                  (\ e ->
                                     do withColor Red $ output e
                                        return Nothing)
                                  $ fst <$> curdir
                         hn <- getHost
                         return (mcd, hn)
       let cd = if isNothing mcd then "? " else fromJust mcd
       ln <- getInputLine $ unwords [cd, "@", hn ++ ">>"]
       if ln == "exit" then exit else
         do hand_ $ command ln
            mainCicle
 
exit :: FTPLine ()
exit
  = do _ <- hand (\ _ -> return failure) $ withColor Green disconnect
       outputStrLn "Closing FTPLine."

Про организацию кода не знаю, но думаю тоже все не плохо.

Перспективы мне кажется, большие у него, но всё упирается в обучаемость и рентабельность.

Если удариться в метафизику, то создание компьютера - это попытка воссоздать интеллект. Соответственно лучший компьютер - это тот, который максимально эффективно и точно повторяет человеческий разум. А лучшая программа - это набор идей, наиболее близких разуму. Я думаю математика в этом плане в более выигрышном положении.

Аватара пользователя
Z
Участник Клуба
Участник Клуба
Сообщения: 6472
Зарегистрирован: 26 июл 2009 08:48
Обучение магии, это:: Жизнь. Ты можешь это принять или это отрицать, но ты всё равно учишься. Быстро или медленно, твой выбор только в этом.
Откуда: Томск
Благодарил (а): 601 раз
Поблагодарили: 474 раза
Контактная информация:

Сообщение Z » 02 апр 2014 15:44

Время покажет..
Свет всегда светит и все освещает, научись принять его, и сам будешь свет..

Аватара пользователя
Амонар
Сообщения: 2440
Зарегистрирован: 19 ноя 2010 20:02
Благодарил (а): 13 раз
Поблагодарили: 131 раз
Контактная информация:

Сообщение Амонар » 27 июн 2014 11:06

Я тут подумал... (Сразу прошу простить, ну и указать на это, если мои размышления на эзотерической почве будут неверные или дилетантские, но на данный момент я всё представляю примерно так)

Есть два способа мышления, грубо говоря: вишудха (чистая логика) и манипура (что-то вроде образного мышления). Вишудха - это всегда немного манипуры, а манипура - всегда немного вишудхи, то есть можно представить это как единый механизм с двумя крайними положениями акцентировки на образе или идее. Люди на манипуре могут отлично знать математику, логику и т.п., но они оперируют ею по принципу потребления готовых продуктов мышления, а не идейного какого-то осмысления. И их теории часто являтся простыми компиляциями, исследованиями каких-то областей и т.п. (например, современные научные сообщества).

Я во многих областях компьютерных технологий чувствую именно идейную составляющую, то, что за этим стоит. Это теория алгоритмов, реляционная теория, сетевые технологии и т.д. А во многих наоборот не чувствую - в них я как бы не нахожу смысла, зачем это так сделано и почему не по-другому, на чем основаны эти положения и т.п. Это вот и ООП в том числе, и сама методология разработки ПО в каких-то вопросах. Например, возможно я не в курсе, я не встречал пока никакой теории декомпозиции программ, и всё это остается на уровне ремесла, а не науки.

Аватара пользователя
Z
Участник Клуба
Участник Клуба
Сообщения: 6472
Зарегистрирован: 26 июл 2009 08:48
Обучение магии, это:: Жизнь. Ты можешь это принять или это отрицать, но ты всё равно учишься. Быстро или медленно, твой выбор только в этом.
Откуда: Томск
Благодарил (а): 601 раз
Поблагодарили: 474 раза
Контактная информация:

Сообщение Z » 04 июл 2014 19:03

Ant писал(а):Есть два способа мышления, грубо говоря: вишудха (чистая логика) и манипура (что-то вроде образного мышления). Вишудха - это всегда немного манипуры, а манипура - всегда немного вишудхи, то есть можно представить это как единый механизм с двумя крайними положениями акцентировки на образе или идее. Люди на манипуре могут отлично знать математику, логику и т.п., но они оперируют ею по принципу потребления готовых продуктов мышления, а не идейного какого-то осмысления. И их теории часто являтся простыми компиляциями, исследованиями каких-то областей и т.п. (например, современные научные сообщества).


В общем да.. Только, и в том и другом случае работают образы. То есть и там и там мышление будет образным, просто эти образы отличаются по частотам. То есть "чистая логика" - это чистые образы.
Свет всегда светит и все освещает, научись принять его, и сам будешь свет..

Аватара пользователя
Амонар
Сообщения: 2440
Зарегистрирован: 19 ноя 2010 20:02
Благодарил (а): 13 раз
Поблагодарили: 131 раз
Контактная информация:

Сообщение Амонар » 22 июн 2015 18:51

Я тут понял в чём проблема. Если ещё кому-то интересно. ООП имеет истоки в теории типов. Но т.к. почти (или не почти) во всех ВУЗах России компьютерное образование кастрированное и оторванное от реальности, то на выходе получаем ущербное понимание годной парадигмы.

Ещё прикол в том, что существуют два рода программистов: олдскульщики и пионеры. Первым мозги проели про производительность и оптимизацию, а вторым про композицию и шаблоны проектирования. И никто не понимает, что это два разных измерения, в общем случае противоречащие друг другу. Поэтому "хороший программист" (как ему кажется) пытается разорваться на две части, наслушавшись советов от всяких недогуру.

Аватара пользователя
Амонар
Сообщения: 2440
Зарегистрирован: 19 ноя 2010 20:02
Благодарил (а): 13 раз
Поблагодарили: 131 раз
Контактная информация:

Сообщение Амонар » 12 сен 2015 19:17

Эльфы пишут на функциональных, сложных, и необычных языках. Пишут в одиночку, столетиями запиливая без релиза очень сложные шедевры. После релиза они выкладывают их в опенсорс (любишь — отпусти), багов в их программах практически нет, но если уж есть, то уровня «это кольцо порабощает все живое». С презрением относятся к энтерпрайзу и внедрению, обычно программу внедряют ровно один раз и в одном месте, для нового случая делается новый шедевр. «Переносимость нужна людям, не умеющим писать новые программы». так сказать. Иногда их шедевры попадают в руки оркам, тогда они становятся окружены уродливыми подпорками и «улучшениями», но это недолго, лет через десять особо инициативный урук «перепишет велосипед» в энтерпрайз стиле, добавив в проект заодно 15 новых зависимостей.

Гномы — это программисты под ебмедед. Пишут на чистом хардкорном C, юнит-тестов, модульности, переиспользования кода, сторонних библиотек и прочего не признают. Пишут один раз, добротно и на совесть, потом пару лет отладки путем трассировки — и вот надежный результат, который потом отливается в камне и используется для управления полетом на Луну. Красивостей. UX, GUI и всего этого не используют (впрочем, UI в их представлении — это хардварная кнопка). Презирают новомодное веяние объекто-ориентированного программирования.

Хоббиты пишут для души и немного. Мелкие полезные удобные утилиты, без претензий, но хорошо работающие. Хоббиты организуют user group и вдумчиво пьют там чай, но больше говорят там о жизни, чем о программировании. Раз в столетие один из хоббитов уезжает в США и пишет там ядро операционки.

Орки — программисты в энтерпрайз. Пишут на Java и C# огромные уродливые индустриальные системы. Их лозунг — пусть уродливо, зато настоящий бизнес. Они любят обмазываться фабриками абстрактных контроллеров, которые создают менеджеры, которые запускают воркфлоу, которые инстанцируются через контейнер внедрения зависимостей. От души презирают эльфов и отзываются в них стиле «уродливые хипстеры ебутся в афедрон со своими жабоскриптами, пока мы создаем Настоящие Системы Ентерпрайз Качества». Назгулы заставляют орков писать юнит-тесты, орки ужасно боятся назгулов, но пользы от юнит-тестов не понимают и пишут их в стиле «если в функцию передать „hello“, она напечатает „hello“». Также орки очень любят переиспользование кода, и библиотеки, у Которых-Есть-Немного-Зависимостей-Совсем-Чуть-Зато-Полностью-Решает-Нашу-Проблему. Также они любят ORM, SOAP, WSDL, WCF и вообще кучу аббревиатур.

Люди Запада пишут энтерпрайзный код, но совсем не такой, как тупые орки. Они каждый день на хабре обсуждают новую статью, написанную кем-то из эльфов, и клятвенно обещают внедрить это в новый проект, но в глубине души знают, что им не суждено достичь уровня великих мастеров, поэтому опять делают все как раньше. Код Людей Запада с каждым годом становится все менее эльфийским и все более орочьим, чтобы объяснить это, они ссылаются на то, что магия ушла из мира, и нынешние программисты Кнута не читали, и требования энтерпрайза с каждым годом все ужаснее. Об эльфийских шедеврах им приходиться лишь читать в книгах, чаще им приходиться интегрироваться с огромной орочьей энтепрайз системой. Тогда Люди Запада пишут прочную прослойку, чтобы изолировать себя от орочьего ада, отсылают оркам баги и дизассемблируют их код, чтобы понять его страшную орочью логику, а потом плачут у себя в бложике.

Аватара пользователя
Z
Участник Клуба
Участник Клуба
Сообщения: 6472
Зарегистрирован: 26 июл 2009 08:48
Обучение магии, это:: Жизнь. Ты можешь это принять или это отрицать, но ты всё равно учишься. Быстро или медленно, твой выбор только в этом.
Откуда: Томск
Благодарил (а): 601 раз
Поблагодарили: 474 раза
Контактная информация:

Сообщение Z » 14 сен 2015 19:36

... а потом плачут у себя в бложике.

:rofl:
Свет всегда светит и все освещает, научись принять его, и сам будешь свет..


Вернуться в «Разное»

Кто сейчас на конференции

Сейчас этот форум просматривают: нет зарегистрированных пользователей и 10 гостей

cron
Рейтинг@Mail.ru